ascii-chat
Binary v0.16.50-198-g78f51665f
Library lib/v0.3.2-2240-g78f51665f
Video chat in your terminal
Loading...
Searching...
No Matches
discovery/database.c
Go to the documentation of this file.
3#include <ascii-chat/otel.h>
13
17#include <ascii-chat/log/log.h>
20#include <string.h>
21#include <time.h>
22#include <inttypes.h>
23#include <sodium.h>
24
25// ============================================================================
26// SQL Query Constants (Defined Once - Compile-time string concatenation)
27// ============================================================================
28
29#include "queries.h"
30
32static void generate_uuid(uint8_t uuid_out[SESSION_ID_SIZE]) {
33 randombytes_buf(uuid_out, 16);
34 uuid_out[6] = (uuid_out[6] & 0x0F) | 0x40; // Version 4
35 uuid_out[8] = (uuid_out[8] & 0x3F) | 0x80; // RFC4122 variant
36}
37
41static uint64_t database_get_current_time_ms(void) {
42 uint64_t current_time_ns = time_get_realtime_ns();
43 return time_ns_to_ms(current_time_ns);
44}
45
49static bool verify_password(const char *password, const char *hash) {
50 return crypto_pwhash_str_verify(hash, password, strlen(password)) == 0;
51}
52
59static session_entry_t *load_session_from_row(sqlite3_stmt *stmt) {
61 if (!session) {
62 return NULL;
63 }
64 memset(session, 0, sizeof(*session));
65
66 // Column order from SELECT statements must match:
67 // 0: session_string, 1: session_id, 2: host_pubkey, 3: password_hash,
68 // 4: max_participants, 5: current_participants, 6: capabilities,
69 // 7: has_password, 8: expose_ip_publicly, 9: session_type,
70 // 10: server_address, 11: server_port, 12: created_at, 13: expires_at,
71 // 14: last_activity_at, 15: initiator_id, 16: host_established, 17: host_participant_id,
72 // 18: host_address, 19: host_port, 20: host_connection_type,
73 // 21: in_migration, 22: migration_start_ns
74
75 const char *str = (const char *)sqlite3_column_text(stmt, 0);
76 if (str) {
77 SAFE_STRNCPY(session->session_string, str, sizeof(session->session_string));
78 }
79
80 const void *blob = sqlite3_column_blob(stmt, 1);
81 if (blob) {
82 memcpy(session->session_id, blob, SESSION_ID_SIZE);
83 }
84
85 blob = sqlite3_column_blob(stmt, 2);
86 if (blob) {
87 memcpy(session->host_pubkey, blob, ED25519_PUBLIC_KEY_SIZE);
88 }
89
90 str = (const char *)sqlite3_column_text(stmt, 3);
91 if (str) {
92 SAFE_STRNCPY(session->password_hash, str, sizeof(session->password_hash));
93 }
94
95 session->max_participants = (uint8_t)sqlite3_column_int(stmt, 4);
96 session->current_participants = (uint8_t)sqlite3_column_int(stmt, 5);
97 session->capabilities = (uint8_t)sqlite3_column_int(stmt, 6);
98 session->has_password = sqlite3_column_int(stmt, 7) != 0;
99 session->expose_ip_publicly = sqlite3_column_int(stmt, 8) != 0;
100 session->session_type = (uint8_t)sqlite3_column_int(stmt, 9);
101
102 str = (const char *)sqlite3_column_text(stmt, 10);
103 if (str) {
104 SAFE_STRNCPY(session->server_address, str, sizeof(session->server_address));
105 }
106
107 session->server_port = (uint16_t)sqlite3_column_int(stmt, 11);
108 session->created_at = (uint64_t)sqlite3_column_int64(stmt, 12);
109 session->expires_at = (uint64_t)sqlite3_column_int64(stmt, 13);
110 session->last_activity_at = (uint64_t)sqlite3_column_int64(stmt, 14);
111
112 // Discovery mode host negotiation fields
113 blob = sqlite3_column_blob(stmt, 15);
114 if (blob) {
115 memcpy(session->initiator_id, blob, SESSION_ID_SIZE);
116 }
117
118 session->host_established = sqlite3_column_int(stmt, 16) != 0;
119
120 blob = sqlite3_column_blob(stmt, 17);
121 if (blob) {
122 memcpy(session->host_participant_id, blob, SESSION_ID_SIZE);
123 }
124
125 str = (const char *)sqlite3_column_text(stmt, 18);
126 if (str) {
127 SAFE_STRNCPY(session->host_address, str, sizeof(session->host_address));
128 }
129
130 session->host_port = (uint16_t)sqlite3_column_int(stmt, 19);
131 session->host_connection_type = (uint8_t)sqlite3_column_int(stmt, 20);
132
133 // Host migration state
134 session->in_migration = sqlite3_column_int(stmt, 21) != 0;
135 session->migration_start_ns = (uint64_t)sqlite3_column_int64(stmt, 22);
136
137 return session;
138}
139
143static void load_session_participants(sqlite3 *db, session_entry_t *session) {
144 const char *sql = database_queries[DATABASE_QUERY_GetSessionParticipants].sql;
145
146 sqlite3_stmt *stmt = NULL;
147 if (ascii_otel_sqlite_prepare(db, sql, &stmt) != SQLITE_OK) {
148 return;
149 }
150
151 if ((sqlite3_bind_text(stmt, sqlite3_bind_parameter_index(stmt, ":session_string"), session->session_string, -1, SQLITE_STATIC) != SQLITE_OK)) {
152 sqlite3_finalize(stmt);
153 log_error("Failed to bind SQLite query parameters");
154 return;
155 }
156
157 size_t idx = 0;
158 while (sqlite3_step(stmt) == SQLITE_ROW && idx < MAX_SESSION_PARTICIPANTS) {
160 if (!p) {
161 break;
162 }
163 memset(p, 0, sizeof(*p));
164
165 const void *blob = sqlite3_column_blob(stmt, 0);
166 if (blob) {
167 memcpy(p->participant_id, blob, SESSION_ID_SIZE);
168 }
169
170 blob = sqlite3_column_blob(stmt, 1);
171 if (blob) {
173 }
174
175 p->joined_at = (uint64_t)sqlite3_column_int64(stmt, 2);
176
177 session->participants[idx++] = p;
178 }
179
180 sqlite3_finalize(stmt);
181}
182
183// ============================================================================
184// Database Lifecycle
185// ============================================================================
186
187asciichat_error_t database_init(const char *db_path, sqlite3 **db) {
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}
296
297void database_close(sqlite3 *db) {
298 ASCII_OTEL_SCOPE(DATABASE_CLOSE);
299 if (!db) {
300 return;
301 }
302 sqlite3_close(db);
303 log_debug("Database closed");
304}
305
306// ============================================================================
307// Session Operations
308// ============================================================================
309
310static asciichat_error_t database_session_create_row(sqlite3 *db, const acip_session_create_t *req, const acds_config_t *config, acip_session_created_t *resp) {
311 ASCII_OTEL_SCOPE(DATABASE_SESSION_CREATE);
312 if (!db || !req || !config || !resp) {
313 return SET_ERRNO(ERROR_INVALID_PARAM, "db, req, config, or resp is NULL");
314 }
315
316 memset(resp, 0, sizeof(*resp));
317
318 // Generate or use reserved session string
319 char session_string[ACIP_MAX_SESSION_STRING_LEN] = {0};
320 if (req->reserved_string_len > 0) {
321 const char *reserved_str = (const char *)(req + 1);
322 size_t len = req->reserved_string_len < (ACIP_MAX_SESSION_STRING_LEN - 1) ? req->reserved_string_len : (ACIP_MAX_SESSION_STRING_LEN - 1);
323 memcpy(session_string, reserved_str, len);
324 session_string[len] = '\0';
325
326 if (!is_session_string(session_string)) {
328 if (HAS_ERRNO(&ctx)) {
329 return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid session string: %s (%s)", session_string, ctx.context_message);
330 }
331 return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid session string: %s", session_string);
332 }
333 } else {
334 asciichat_error_t result = acds_string_generate(session_string, sizeof(session_string));
335 if (result != ASCIICHAT_OK) {
336 return result;
337 }
338 }
339
340 // Generate session ID
342 generate_uuid(session_id);
343
344 // Set timestamps
345 uint64_t now = database_get_current_time_ms();
346 uint64_t expires_at = now + ACIP_SESSION_EXPIRATION_MS;
347
348 // Calculate max_participants
349 uint8_t max_participants = req->max_participants > 0 && req->max_participants <= MAX_SESSION_PARTICIPANTS ? req->max_participants : MAX_SESSION_PARTICIPANTS;
350
351 // Insert into database
352 const char *sql = database_queries[DATABASE_QUERY_CreateSession].sql;
353
354 sqlite3_stmt *stmt = NULL;
355 int rc = ascii_otel_sqlite_prepare(db, sql, &stmt);
356 if (rc != SQLITE_OK) {
357 if (rc == SQLITE_BUSY || rc == SQLITE_LOCKED)
358 ascii_otel_metric(ASCII_OTEL_METRIC_DB_BUSY, 1);
359 return SET_ERRNO(ERROR_CONFIG, "Failed to prepare session insert: %s", sqlite3_errmsg(db));
360 }
361
362 log_info("expose_ip_publicly=%d, server_address='%s' server_port=%u, session_type=%u, "
363 "has_password=%u",
364 req->expose_ip_publicly, req->server_address, req->server_port, req->session_type, req->has_password);
365 if ((sqlite3_bind_text(stmt, sqlite3_bind_parameter_index(stmt, ":session_string"), session_string, -1, SQLITE_STATIC) != SQLITE_OK) ||
366 (sqlite3_bind_blob(stmt, sqlite3_bind_parameter_index(stmt, ":session_id"), session_id, 16, SQLITE_STATIC) != SQLITE_OK) ||
367 (sqlite3_bind_blob(stmt, sqlite3_bind_parameter_index(stmt, ":host_pubkey"), req->identity_pubkey, 32, SQLITE_STATIC) != SQLITE_OK) ||
368 (sqlite3_bind_text(stmt, sqlite3_bind_parameter_index(stmt, ":password_hash"), req->has_password ? (const char *)req->password_hash : NULL, -1, SQLITE_STATIC) != SQLITE_OK) ||
369 (sqlite3_bind_int(stmt, sqlite3_bind_parameter_index(stmt, ":max_participants"), max_participants) != SQLITE_OK) ||
370 (sqlite3_bind_int(stmt, sqlite3_bind_parameter_index(stmt, ":capabilities"), req->capabilities) != SQLITE_OK) ||
371 (sqlite3_bind_int(stmt, sqlite3_bind_parameter_index(stmt, ":has_password"), req->has_password ? 1 : 0) != SQLITE_OK) ||
372 (sqlite3_bind_int(stmt, sqlite3_bind_parameter_index(stmt, ":expose_ip_publicly"), req->expose_ip_publicly ? 1 : 0) != SQLITE_OK) ||
373 (sqlite3_bind_int(stmt, sqlite3_bind_parameter_index(stmt, ":session_type"), req->session_type) != SQLITE_OK) ||
374 (sqlite3_bind_text(stmt, sqlite3_bind_parameter_index(stmt, ":server_address"), req->server_address, -1, SQLITE_STATIC) != SQLITE_OK) ||
375 (sqlite3_bind_int(stmt, sqlite3_bind_parameter_index(stmt, ":server_port"), req->server_port) != SQLITE_OK) ||
376 (sqlite3_bind_int64(stmt, sqlite3_bind_parameter_index(stmt, ":created_at"), (sqlite3_int64)now) != SQLITE_OK) ||
377 (sqlite3_bind_int64(stmt, sqlite3_bind_parameter_index(stmt, ":expires_at"), (sqlite3_int64)expires_at) != SQLITE_OK) ||
378 (sqlite3_bind_int64(stmt, sqlite3_bind_parameter_index(stmt, ":last_activity_at"), (sqlite3_int64)now) != SQLITE_OK)) {
379 sqlite3_finalize(stmt);
380 return SET_ERRNO(ERROR_CONFIG, "Failed to bind SQLite query parameters");
381 }
382
383 rc = sqlite3_step(stmt);
384 if (rc == SQLITE_DONE && !sqlite3_stmt_readonly(stmt))
385 ascii_otel_metric(ASCII_OTEL_METRIC_DB_ROWS, sqlite3_changes(db));
386 sqlite3_finalize(stmt);
387
388 if (rc != SQLITE_DONE) {
389 if (rc == SQLITE_BUSY || rc == SQLITE_LOCKED)
390 ascii_otel_metric(ASCII_OTEL_METRIC_DB_BUSY, 1);
391 if (rc == SQLITE_CONSTRAINT) {
392 return SET_ERRNO(ERROR_INVALID_STATE, "Session string already exists: %s", session_string);
393 }
394 return SET_ERRNO(ERROR_CONFIG, "Failed to insert session: %s", sqlite3_errmsg(db));
395 }
396
397 // Fill response
398 resp->session_string_len = (uint8_t)strlen(session_string);
399 SAFE_STRNCPY(resp->session_string, session_string, sizeof(resp->session_string));
400 memcpy(resp->session_id, session_id, SESSION_ID_SIZE);
401 resp->expires_at = expires_at;
402 resp->stun_count = config->stun_count;
403 resp->turn_count = config->turn_count;
404
405 log_info("Session created: %s (session_id=%02x%02x%02x%02x..., max_participants=%d, has_password=%d)", session_string, session_id[0], session_id[1], session_id[2], session_id[3], max_participants,
406 req->has_password ? 1 : 0);
407
408 return ASCIICHAT_OK;
409}
410
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}
416
419static asciichat_error_t database_session_create_keys_locked(sqlite3 *db, const acip_session_create_t *req, const uint8_t (*keys)[32], size_t count, const acds_config_t *config,
420 acip_session_created_t *resp, const void *metadata, size_t metadata_length) {
421 if (!db || !req || !keys || !config || !resp || count == 0 || count > MAX_SESSION_KEYS)
422 return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid session key set");
423 memset(resp, 0, sizeof(*resp));
424 if ((req->total_keys ? req->total_keys : 1) != count || req->key_index != 0)
425 return SET_ERRNO(ERROR_INVALID_PARAM, "Create count does not match key set");
426 if (memcmp(keys[0], req->identity_pubkey, sizeof(req->identity_pubkey)) != 0)
427 return SET_ERRNO(ERROR_INVALID_PARAM, "Primary key does not match create request");
428 for (size_t i = 0; i < count; ++i) {
429 if (count > 1 && sodium_is_zero(keys[i], 32))
430 return SET_ERRNO(ERROR_INVALID_PARAM, "Anonymous keys cannot authorize a restricted session");
431 for (size_t j = 0; j < i; ++j)
432 if (memcmp(keys[i], keys[j], sizeof(keys[i])) == 0)
433 return SET_ERRNO(ERROR_INVALID_PARAM, "Duplicate Ed25519 key");
434 }
435 if (sqlite3_exec(db, database_queries[DATABASE_QUERY_BeginKeySet].sql, NULL, NULL, NULL) != SQLITE_OK)
436 return SET_ERRNO(ERROR_CONFIG, "Could not begin key-set creation");
437 asciichat_error_t result = database_session_create_row(db, req, config, resp);
438 sqlite3_stmt *stmt = NULL;
439 if (result == ASCIICHAT_OK) {
440 int rc = ascii_otel_sqlite_prepare(db, database_queries[DATABASE_QUERY_InsertSessionKeyPolicy].sql, &stmt);
441 if (rc == SQLITE_OK) {
442 rc = sqlite3_bind_text(stmt, sqlite3_bind_parameter_index(stmt, ":session_string"), resp->session_string, -1, SQLITE_STATIC);
443 if (rc == SQLITE_OK)
444 rc = sqlite3_bind_int(stmt, sqlite3_bind_parameter_index(stmt, ":restricted"), count > 1);
445 if (rc == SQLITE_OK)
446 rc = sqlite3_step(stmt);
447 }
448 sqlite3_finalize(stmt);
449 if (rc != SQLITE_DONE)
450 result = SET_ERRNO(ERROR_CONFIG, "Could not persist session key policy");
451 }
452 for (size_t i = 0; result == ASCIICHAT_OK && i < count; ++i) {
453 if (!sodium_is_zero(keys[i], 32))
454 result = database_session_add_key(db, resp->session_string, keys[i], (uint32_t)i);
455 }
456 if (result == ASCIICHAT_OK && metadata_length)
457 result = database_session_transport_set(db, resp->session_id, metadata, metadata_length);
458 if (result == ASCIICHAT_OK && sqlite3_exec(db, database_queries[DATABASE_QUERY_CommitKeySet].sql, NULL, NULL, NULL) != SQLITE_OK)
459 result = SET_ERRNO(ERROR_CONFIG, "Could not commit session key set");
460 if (result != ASCIICHAT_OK) {
461 if (sqlite3_exec(db, database_queries[DATABASE_QUERY_RollbackToKeySet].sql, NULL, NULL, NULL) == SQLITE_OK)
462 sqlite3_exec(db, database_queries[DATABASE_QUERY_CommitKeySet].sql, NULL, NULL, NULL);
463 memset(resp, 0, sizeof(*resp));
464 }
465 return result;
466}
467
468asciichat_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,
469 acip_session_created_t *resp, const void *metadata, size_t metadata_length) {
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}
480
481asciichat_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) {
482 return database_session_create_keys_with_transport(db, req, keys, count, config, resp, NULL, 0);
483}
484
485asciichat_error_t database_session_lookup(sqlite3 *db, const char *session_string, const acds_config_t *config, acip_session_info_t *resp) {
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}
549
552static asciichat_error_t database_session_authorize_join(sqlite3 *db, const acip_session_join_t *req, const acds_config_t *config, const char *session_string, acip_session_joined_t *resp) {
553 sqlite3_stmt *policy = NULL;
554 int policy_rc = ascii_otel_sqlite_prepare(db, database_queries[DATABASE_QUERY_GetSessionKeyPolicy].sql, &policy);
555 if (policy_rc == SQLITE_OK) {
556 policy_rc = sqlite3_bind_text(policy, sqlite3_bind_parameter_index(policy, ":session_string"), session_string, -1, SQLITE_STATIC);
557 if (policy_rc == SQLITE_OK)
558 policy_rc = sqlite3_step(policy);
559 }
560 bool restricted = policy_rc == SQLITE_ROW && sqlite3_column_int(policy, 0) != 0;
561 sqlite3_finalize(policy);
562 if (policy_rc != SQLITE_ROW) {
563 return SET_ERRNO(ERROR_CONFIG, "Missing session key policy");
564 }
565 // Restricted admission always requires a current proof, regardless of the
566 // service-wide optional identity setting. An advertised key alone is no proof.
567 if ((restricted && !database_session_verify_key(db, session_string, req->identity_pubkey)) ||
568 ((restricted || config->require_client_identity) &&
569 (!acds_validate_timestamp(req->timestamp, 300) || acds_verify_session_join(req->identity_pubkey, req->timestamp, session_string, req->signature) != ASCIICHAT_OK))) {
570 resp->error_code = ACIP_ERROR_INVALID_SIGNATURE;
571 SAFE_STRNCPY(resp->error_message, "Session key authorization failed", sizeof(resp->error_message));
572 return ASCIICHAT_OK;
573 }
574
575 return ASCIICHAT_OK;
576}
577
580static asciichat_error_t database_session_join_commit(sqlite3 *db, const acip_session_join_t *req, const acds_config_t *config, const session_entry_t *verified, acip_session_joined_t *resp,
581 session_entry_t **joined) {
582 // Generate participant ID
584 generate_uuid(participant_id);
585 uint64_t now = database_get_current_time_ms();
586
587 // Begin transaction
588 char *err_msg = NULL;
589 int rc = sqlite3_exec(db, database_queries[DATABASE_QUERY_BeginTransaction].sql, NULL, NULL, &err_msg);
590 if (rc != SQLITE_OK) {
591 if (rc == SQLITE_BUSY || rc == SQLITE_LOCKED)
592 ascii_otel_metric(ASCII_OTEL_METRIC_DB_BUSY, 1);
593 log_error("Failed to begin transaction: %s", err_msg ? err_msg : "unknown");
594 sqlite3_free(err_msg);
595 return SET_ERRNO(ERROR_CONFIG, "Failed to begin transaction");
596 }
597
598 // Reload inside the transaction: other joins or key administration may have
599 // run while this thread was verifying the password without the database lock.
600 const char *session_string = verified->session_string;
601 session_entry_t *session = database_session_find_by_string(db, session_string);
602 if (!session || memcmp(session->session_id, verified->session_id, sizeof(session->session_id)) != 0) {
603 sqlite3_exec(db, database_queries[DATABASE_QUERY_RollbackTransaction].sql, NULL, NULL, NULL);
604 session_entry_destroy(session);
605 resp->error_code = ACIP_ERROR_SESSION_NOT_FOUND;
606 SAFE_STRNCPY(resp->error_message, "Session changed during join", sizeof(resp->error_message));
607 return ASCIICHAT_OK;
608 }
609 asciichat_error_t result = database_session_authorize_join(db, req, config, session_string, resp);
610 if (result != ASCIICHAT_OK || resp->error_code != ACIP_ERROR_NONE) {
611 sqlite3_exec(db, database_queries[DATABASE_QUERY_RollbackTransaction].sql, NULL, NULL, NULL);
612 session_entry_destroy(session);
613 return result;
614 }
615 if (session->has_password != verified->has_password || strcmp(session->password_hash, verified->password_hash) != 0) {
616 sqlite3_exec(db, database_queries[DATABASE_QUERY_RollbackTransaction].sql, NULL, NULL, NULL);
617 session_entry_destroy(session);
618 resp->error_code = ACIP_ERROR_INVALID_PASSWORD;
619 SAFE_STRNCPY(resp->error_message, "Session password changed; retry join", sizeof(resp->error_message));
620 return ASCIICHAT_OK;
621 }
622 if (session->current_participants >= session->max_participants) {
623 sqlite3_exec(db, database_queries[DATABASE_QUERY_RollbackTransaction].sql, NULL, NULL, NULL);
624 session_entry_destroy(session);
625 resp->error_code = ACIP_ERROR_SESSION_FULL;
626 SAFE_STRNCPY(resp->error_message, "Session is full", sizeof(resp->error_message));
627 return ASCIICHAT_OK;
628 }
629
630 // Insert participant
631 const char *insert_sql = database_queries[DATABASE_QUERY_InsertParticipant].sql;
632 sqlite3_stmt *stmt = NULL;
633 rc = ascii_otel_sqlite_prepare(db, insert_sql, &stmt);
634 if (rc != SQLITE_OK) {
635 if (rc == SQLITE_BUSY || rc == SQLITE_LOCKED)
636 ascii_otel_metric(ASCII_OTEL_METRIC_DB_BUSY, 1);
637 sqlite3_exec(db, database_queries[DATABASE_QUERY_RollbackTransaction].sql, NULL, NULL, NULL);
638 session_entry_destroy(session);
639 return SET_ERRNO(ERROR_CONFIG, "Failed to prepare participant insert: %s", sqlite3_errmsg(db));
640 }
641
642 if ((sqlite3_bind_blob(stmt, sqlite3_bind_parameter_index(stmt, ":participant_id"), participant_id, 16, SQLITE_STATIC) != SQLITE_OK) ||
643 (sqlite3_bind_text(stmt, sqlite3_bind_parameter_index(stmt, ":session_string"), session->session_string, -1, SQLITE_STATIC) != SQLITE_OK) ||
644 (sqlite3_bind_blob(stmt, sqlite3_bind_parameter_index(stmt, ":identity_pubkey"), req->identity_pubkey, 32, SQLITE_STATIC) != SQLITE_OK) ||
645 (sqlite3_bind_int64(stmt, sqlite3_bind_parameter_index(stmt, ":joined_at"), (sqlite3_int64)now) != SQLITE_OK)) {
646 sqlite3_finalize(stmt);
647 sqlite3_exec(db, database_queries[DATABASE_QUERY_RollbackTransaction].sql, NULL, NULL, NULL);
648 session_entry_destroy(session);
649 return SET_ERRNO(ERROR_CONFIG, "Failed to bind SQLite query parameters");
650 }
651
652 rc = sqlite3_step(stmt);
653 if (rc == SQLITE_DONE && !sqlite3_stmt_readonly(stmt))
654 ascii_otel_metric(ASCII_OTEL_METRIC_DB_ROWS, sqlite3_changes(db));
655 sqlite3_finalize(stmt);
656
657 if (rc != SQLITE_DONE) {
658 if (rc == SQLITE_BUSY || rc == SQLITE_LOCKED)
659 ascii_otel_metric(ASCII_OTEL_METRIC_DB_BUSY, 1);
660 sqlite3_exec(db, database_queries[DATABASE_QUERY_RollbackTransaction].sql, NULL, NULL, NULL);
661 session_entry_destroy(session);
662 return SET_ERRNO(ERROR_CONFIG, "Failed to insert participant: %s", sqlite3_errmsg(db));
663 }
664
665 // Update participant count and last activity
666 const char *update_sql = database_queries[DATABASE_QUERY_IncrementParticipants].sql;
667 rc = ascii_otel_sqlite_prepare(db, update_sql, &stmt);
668 if (rc == SQLITE_OK) {
669 if ((sqlite3_bind_int64(stmt, sqlite3_bind_parameter_index(stmt, ":last_activity_at"), (sqlite3_int64)now) != SQLITE_OK) ||
670 (sqlite3_bind_text(stmt, sqlite3_bind_parameter_index(stmt, ":session_string"), session->session_string, -1, SQLITE_STATIC) != SQLITE_OK)) {
671 sqlite3_finalize(stmt);
672 sqlite3_exec(db, database_queries[DATABASE_QUERY_RollbackTransaction].sql, NULL, NULL, NULL);
673 session_entry_destroy(session);
674 return SET_ERRNO(ERROR_CONFIG, "Failed to bind SQLite query parameters");
675 }
676 sqlite3_step(stmt);
677 sqlite3_finalize(stmt);
678 }
679
680 // Set initiator_id if this is the first participant (for discovery mode tiebreaker)
681 bool is_first_participant = (session->current_participants == 0);
682 bool is_zero_initiator = true;
683 for (int i = 0; i < 16; i++) {
684 if (session->initiator_id[i] != 0) {
685 is_zero_initiator = false;
686 break;
687 }
688 }
689
690 if (is_first_participant || is_zero_initiator) {
691 const char *initiator_sql = database_queries[DATABASE_QUERY_SetSessionInitiator].sql;
692 rc = ascii_otel_sqlite_prepare(db, initiator_sql, &stmt);
693 if (rc == SQLITE_OK) {
694 if ((sqlite3_bind_blob(stmt, sqlite3_bind_parameter_index(stmt, ":initiator_id"), participant_id, 16, SQLITE_STATIC) != SQLITE_OK) ||
695 (sqlite3_bind_text(stmt, sqlite3_bind_parameter_index(stmt, ":session_string"), session->session_string, -1, SQLITE_STATIC) != SQLITE_OK)) {
696 sqlite3_finalize(stmt);
697 sqlite3_exec(db, database_queries[DATABASE_QUERY_RollbackTransaction].sql, NULL, NULL, NULL);
698 session_entry_destroy(session);
699 return SET_ERRNO(ERROR_CONFIG, "Failed to bind SQLite query parameters");
700 }
701 sqlite3_step(stmt);
702 sqlite3_finalize(stmt);
704 log_debug("Set initiator_id to new participant %02x%02x...", participant_id[0], participant_id[1]);
705 }
706 }
707
708 // Commit transaction
709 rc = sqlite3_exec(db, database_queries[DATABASE_QUERY_CommitTransaction].sql, NULL, NULL, &err_msg);
710 if (rc != SQLITE_OK) {
711 if (rc == SQLITE_BUSY || rc == SQLITE_LOCKED)
712 ascii_otel_metric(ASCII_OTEL_METRIC_DB_BUSY, 1);
713 log_error("Failed to commit transaction: %s", err_msg ? err_msg : "unknown");
714 sqlite3_free(err_msg);
715 sqlite3_exec(db, database_queries[DATABASE_QUERY_RollbackTransaction].sql, NULL, NULL, NULL);
716 session_entry_destroy(session);
717 return SET_ERRNO(ERROR_CONFIG, "Failed to commit transaction");
718 }
719
720 memcpy(resp->participant_id, participant_id, sizeof(resp->participant_id));
721 *joined = session;
722 return ASCIICHAT_OK;
723}
724
726static void database_session_join_response(session_entry_t *session, const acds_config_t *config, acip_session_joined_t *resp) {
727 const char *session_string = session->session_string;
728 // Fill response
729 resp->success = 1;
730 resp->error_code = ACIP_ERROR_NONE;
731 memcpy(resp->session_id, session->session_id, SESSION_ID_SIZE);
732
733 // Discovery mode host negotiation fields
734 memcpy(resp->initiator_id, session->initiator_id, SESSION_ID_SIZE);
735 resp->host_established = session->host_established ? 1 : 0;
736 if (session->host_established) {
737 memcpy(resp->host_id, session->host_participant_id, SESSION_ID_SIZE);
738 }
739 // peer_count = current_participants (excluding self) that need to negotiate
740 resp->peer_count = session->current_participants; // Will be incremented after this returns
741 // The transport type is not private server-address data. WebRTC clients need
742 // it to choose the signaling path even while the server IP remains hidden.
743 resp->session_type = session->session_type;
744
745 log_debug("SESSION_JOIN response: session_id=%02x%02x%02x%02x..., participant_id=%02x%02x%02x%02x..., "
746 "initiator=%02x%02x..., host_established=%d, peer_count=%d",
747 resp->session_id[0], resp->session_id[1], resp->session_id[2], resp->session_id[3], resp->participant_id[0], resp->participant_id[1], resp->participant_id[2], resp->participant_id[3],
748 resp->initiator_id[0], resp->initiator_id[1], resp->host_established, resp->peer_count);
749
750 // IP disclosure logic
751 log_debug("has_password=%d, expose_ip_publicly=%d, server_address='%s'", session->has_password, session->expose_ip_publicly, session->server_address);
752 bool reveal_ip = session->has_password || session->expose_ip_publicly;
753 log_debug("reveal_ip=%d", reveal_ip);
754
755 if (reveal_ip) {
756 SAFE_STRNCPY(resp->server_address, session->server_address, sizeof(resp->server_address));
757 resp->server_port = session->server_port;
758 // Generate TURN credentials for WebRTC sessions
759 if (session->session_type == SESSION_TYPE_WEBRTC && config->turn_secret[0] != '\0') {
760 turn_credentials_t turn_creds;
761 asciichat_error_t turn_result = turn_generate_credentials(session_string, config->turn_secret, 86400, &turn_creds);
762 if (turn_result == ASCIICHAT_OK) {
763 SAFE_STRNCPY(resp->turn_username, turn_creds.username, sizeof(resp->turn_username));
764 SAFE_STRNCPY(resp->turn_password, turn_creds.password, sizeof(resp->turn_password));
765 log_debug("Generated TURN credentials for session %s", session_string);
766 }
767 }
768
769 log_info("Participant joined session %s (participants=%d/%d, server=%s:%d, type=%s)", session_string, session->current_participants + 1, session->max_participants, resp->server_address,
770 resp->server_port, session->session_type == SESSION_TYPE_WEBRTC ? "WebRTC" : "DirectTCP");
771 } else {
772 log_info("Participant joined session %s (participants=%d/%d, IP WITHHELD)", session_string, session->current_participants + 1, session->max_participants);
773 }
774
775 ascii_otel_call_session_used(session_string);
776
777 session_entry_destroy(session);
778}
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}
856
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}
1010
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}
1040
1041session_entry_t *database_session_find_by_string(sqlite3 *db, const char *session_string) {
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}
1070
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}
1119
1120asciichat_error_t database_session_update_host(sqlite3 *db, const uint8_t session_id[SESSION_ID_SIZE], const uint8_t host_participant_id[SESSION_ID_SIZE], const char *host_address, uint16_t host_port,
1121 uint8_t connection_type) {
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}
1172
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}
1214
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}
1259
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}
1298
1299// ============================================================================
1300// Multi-Key Management Functions
1301// ============================================================================
1302
1303asciichat_error_t database_session_add_key(sqlite3 *db, const char *session_string, const uint8_t identity_pubkey[ED25519_PUBLIC_KEY_SIZE], uint32_t key_version) {
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}
1336
1337asciichat_error_t database_session_revoke_key(sqlite3 *db, const char *session_string, const uint8_t identity_pubkey[ED25519_PUBLIC_KEY_SIZE]) {
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}
1368
1369bool database_session_verify_key(sqlite3 *db, const char *session_string, const uint8_t identity_pubkey[ED25519_PUBLIC_KEY_SIZE]) {
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}
1394
1395asciichat_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) {
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}
1428
1429// ============================================================================
1430// Statistics Queries
1431// ============================================================================
1432
1433asciichat_error_t database_stats_session_count(sqlite3 *db, int64_t *count_out) {
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}
1471
1472asciichat_error_t database_stats_unique_clients(sqlite3 *db, int64_t *count_out) {
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}
1504
1505asciichat_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) {
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}
1540
1541asciichat_error_t database_session_transport_set(sqlite3 *db, const uint8_t session_id[SESSION_ID_SIZE], const void *metadata, size_t length) {
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}
1555
1556asciichat_error_t database_session_transport_get(sqlite3 *db, const uint8_t session_id[SESSION_ID_SIZE], void *metadata, size_t capacity, size_t *length) {
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}
1581
1582/* The authority check belongs to the signaling layer holding handoff_mutex.
1583 * Persist endpoint and transport ownership together so failure cannot leave a
1584 * successor paired with the previous host's transport advertisements. */
1586 uint8_t type, const void *metadata, size_t length) {
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 acds_verify_session_join(const uint8_t identity_pubkey[32], uint64_t timestamp, const char *session_string, const uint8_t signature[64])
Verify SESSION_JOIN signature.
bool acds_validate_timestamp(uint64_t timestamp_ms, uint32_t window_seconds)
Check if timestamp is within acceptable window.
ACIP client-side protocol library and ACDS client connection API.
#define ACIP_MAX_SESSION_STRING_LEN
Definition acds_sizes.h:10
#define SET_ERRNO(code,...)
#define HAS_ERRNO(context)
Application limits and constraints.
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_stats_unique_clients(sqlite3 *db, int64_t *count_out)
Get total number of unique clients/participants.
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_clear_host(sqlite3 *db, const uint8_t session_id[16])
Clear session host (discovery mode - host migration).
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_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_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_start_migration(sqlite3 *db, const uint8_t session_id[16])
Start host migration (discovery mode).
asciichat_error_t database_session_leave(sqlite3 *db, const uint8_t session_id[16], const uint8_t participant_id[16])
Leave session.
asciichat_error_t database_stats_session_count(sqlite3 *db, int64_t *count_out)
Get total number of active sessions.
void database_close(sqlite3 *db)
Close database.
session_entry_t * database_session_find_by_id(sqlite3 *db, const uint8_t session_id[16])
Find session by session_id.
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_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)
session_entry_t * database_session_find_by_string(sqlite3 *db, const char *session_string)
Find session by session_string.
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_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_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_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_init(const char *db_path, sqlite3 **db)
Initialize database and create schema.
asciichat_error_t database_session_transport_set(sqlite3 *db, const uint8_t session_id[16], const void *metadata, size_t length)
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_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)
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.
void database_session_cleanup_expired(sqlite3 *db)
Clean up inactive sessions.
bool is_session_string(const char *str)
Check if a string is a valid session string.
asciichat_error_t acds_string_generate(char *output, size_t output_size)
Generate random session string.
bool valid
Definition fft.c:29
unsigned short uint16_t
unsigned int uint32_t
#define SAFE_STRNCPY(dst, src, size)
#define SAFE_MALLOC(size, cast)
unsigned long long uint64_t
unsigned char uint8_t
asciichat_error_t
Error and exit codes - unified status values (0-255).
Definition error_codes.h:48
@ ERROR_INVALID_STATE
@ ASCIICHAT_OK
Definition error_codes.h:50
@ ERROR_NETWORK_SIZE
Definition error_codes.h:81
@ ERROR_CONFIG
Definition error_codes.h:56
@ ERROR_INVALID_PARAM
#define MAX_SESSION_PARTICIPANTS
#define SESSION_ID_SIZE
#define MAX_SESSION_KEYS
#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
#define log_debug(...)
Log a DEBUG message.
Definition log/log.h:589
acip_session_join_t
Definition acds.h:408
acip_session_joined_t
Definition acds.h:479
acip_session_created_t
Definition acds.h:274
acip_session_create_t
Definition acds.h:226
acip_session_info_t
Definition acds.h:360
#define ACIP_SESSION_EXPIRATION_MS
Maximum session string length (e.g., "swift-river-mountain" = 20 chars).
Definition acds.h:1099
@ 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_INVALID_SIGNATURE
Identity signature invalid.
Definition acds.h:1078
@ ACIP_ERROR_NONE
No error (success).
Definition acds.h:1074
@ SESSION_TYPE_WEBRTC
WebRTC P2P mesh with STUN/TURN relay.
Definition acds.h:151
#define SEC_PER_HOUR
Definition time.h:184
#define NS_PER_MS_INT
Definition time.h:172
#define MS_PER_SEC_INT
Definition time.h:180
struct session_entry session_entry_t
Persisted discovery-session record used to admit and route participants.
@ STATS_COUNTER_SESSION_EXPIRATIONS
@ STATS_GAUGE_PARTICIPANTS_ACTIVE
void session_entry_destroy(session_entry_t *entry)
Free a session entry and all its resources.
void stats_counter_add(stats_scope_t *scope, stats_counter_id_t id, uint64_t amount)
void stats_gauge_set(stats_scope_t *scope, stats_gauge_id_t id, uint64_t value)
📝 Logging API with multiple log levels and terminal output control
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
void ascii_otel_call_session_used(const char *session_string)
Definition otel.c:420
#define ASCII_OTEL_SCOPE(id)
Definition otel.h:77
@ DATABASE_QUERY_RollbackTransaction
@ DATABASE_QUERY_GetSessionByString
@ DATABASE_QUERY_RollbackToKeySet
@ DATABASE_QUERY_EnableForeignKeys
@ DATABASE_QUERY_CommitHostTransportRefresh
@ DATABASE_QUERY_SetSessionInitiator
@ DATABASE_QUERY_GetSessionKeys
@ DATABASE_QUERY_SchemaSessionTransports
@ DATABASE_QUERY_CountUniqueClients
@ DATABASE_QUERY_IncrementParticipants
@ DATABASE_QUERY_GetStatsSnapshot
@ DATABASE_QUERY_ImportLegacySessionKeys
@ DATABASE_QUERY_AddSessionKey
@ DATABASE_QUERY_CreateSession
@ DATABASE_QUERY_CommitKeySet
@ DATABASE_QUERY_DeleteExpiredSessions
@ DATABASE_QUERY_EnableWAL
@ DATABASE_QUERY_SchemaParticipants
@ DATABASE_QUERY_SchemaIdxRateEvents
@ DATABASE_QUERY_SchemaIdentityKeys
@ DATABASE_QUERY_GetSessionById
@ DATABASE_QUERY_RevokeSessionKey
@ DATABASE_QUERY_BeginKeySet
@ DATABASE_QUERY_InsertParticipant
@ DATABASE_QUERY_SchemaIdxParticipantsSession
@ DATABASE_QUERY_BackfillSessionKeyPolicy
@ DATABASE_QUERY_ClearHost
@ DATABASE_QUERY_RollbackHostTransportRefresh
@ DATABASE_QUERY_GetParticipantCount
@ DATABASE_QUERY_SchemaClearTransportsTrigger
@ DATABASE_QUERY_COUNT
@ DATABASE_QUERY_UpdateHost
@ DATABASE_QUERY_LookupSessionString
@ DATABASE_QUERY_SchemaSessions
@ DATABASE_QUERY_SchemaSessionTransportHosts
@ DATABASE_QUERY_SchemaIdxSessionsId
@ DATABASE_QUERY_SetSessionTransportHost
@ DATABASE_QUERY_BackfillSessionIdentityKeys
@ DATABASE_QUERY_VerifySessionKey
@ DATABASE_QUERY_GetSessionKeyPolicy
@ DATABASE_QUERY_SchemaIdxSessionsActivity
@ DATABASE_QUERY_SetSessionTransports
@ DATABASE_QUERY_HasLegacySessionKeys
@ DATABASE_QUERY_LookupSession
@ DATABASE_QUERY_DeleteParticipant
@ DATABASE_QUERY_DecrementParticipants
@ DATABASE_QUERY_CommitTransaction
@ DATABASE_QUERY_StartMigration
@ DATABASE_QUERY_InsertSessionKeyPolicy
@ DATABASE_QUERY_DeleteSession
@ DATABASE_QUERY_GetMigrationState
@ DATABASE_QUERY_SchemaRateEvents
@ DATABASE_QUERY_GetSessionParticipants
@ DATABASE_QUERY_SchemaKeyPolicy
@ DATABASE_QUERY_GetSessionTransports
@ DATABASE_QUERY_BeginHostTransportRefresh
@ DATABASE_QUERY_CountSessions
@ DATABASE_QUERY_FindExpiredSessions
@ DATABASE_QUERY_BeginTransaction
enum database_query_id database_query_id_t
stats_scope_t * stats_runtime_scope(void)
Definition runtime.c:78
#define ED25519_PUBLIC_KEY_SIZE
Ed25519 public key size in bytes.
Definition sizes.h:37
uint8_t session_id[SESSION_ID_SIZE]
uint8_t participant_id[SESSION_ID_SIZE]
🔤 String Manipulation and Shell Escaping Utilities
#define SESSION_STRING_BUFFER_SIZE
Discovery server configuration.
bool require_server_verify
ACDS policy: require servers to verify client identity during handshake.
uint8_t turn_count
Number of configured TURN servers (0-4).
char turn_secret[256]
(HMAC-SHA1)
uint8_t stun_count
Number of configured STUN servers (0-4).
bool require_client_identity
Require clients to provide signed identity when joining sessions.
bool require_client_verify
ACDS policy: require clients to verify server identity during handshake.
The useful part of database session stats is in participants, host_ready, migrating: together they de...
Definition database.h:275
Host migration state for collecting HOST_LOST packets.
uint8_t identity_pubkey[32]
Ed25519 public key.
uint64_t joined_at
Unix timestamp (ms).
bool expose_ip_publicly
Allow IP disclosure without verification (explicit opt-in via –acds-expose-ip).
bool has_password
Password protection flag.
uint8_t max_participants
1-128
uint8_t host_pubkey[32]
Host's Ed25519 key.
participant_t * participants[128]
Participant array (in-memory only).
char host_address[ACIP_ADDRESS_SIZE]
uint8_t initiator_id[16]
First participant who created/joined the session.
uint16_t host_port
Host's port (valid if host_established).
uint8_t host_participant_id[16]
Current host's participant_id (valid if host_established).
bool host_established
Whether a host has been designated (false = still negotiating).
char server_address[ACIP_ADDRESS_SIZE]
IPv4/IPv6 address or hostname.
bool in_migration
Currently collecting HOST_LOST packets.
char session_string[(38+1)]
e.g., "affectionate-acquaintance-acquaintance"
char password_hash[ACIP_PASSWORD_HASH_SIZE]
Argon2id hash (if has_password).
uint8_t session_id[16]
UUID.
uint64_t created_at
Unix timestamp (ms) - when session was created.
uint64_t migration_start_ns
When migration started in nanoseconds (for collection window timeout).
uint64_t expires_at
Unix timestamp (ms) - absolute max lifetime (created_at + 24h).
uint8_t capabilities
bit 0: video, bit 1: audio
uint8_t session_type
acds_session_type_t: 0=DIRECT_TCP, 1=WEBRTC
uint64_t last_activity_at
Unix timestamp (ms) - updated on join/leave/host updates (cleanup uses this).
uint16_t server_port
Port number for client connection.
uint8_t current_participants
Active participant count.
uint8_t host_connection_type
acip_connection_type_t: how to reach host
TURN server credentials (username + password).
⏱️ High-precision timing utilities using sokol_time.h and uthash
asciichat_error_t turn_generate_credentials(const char *session_id, const char *secret, uint32_t validity_seconds, turn_credentials_t *out_credentials)
Generate time-limited TURN credentials.
TURN server credential generation for WebRTC.