database.c File Reference

💾 SQLite persistence implementation More...

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.
asciichat_error_t	database_load_sessions (sqlite3 *db, session_registry_t *registry)
	Load active sessions from database into registry.
asciichat_error_t	database_save_session (sqlite3 *db, const session_entry_t *session)
	Save session to database.
asciichat_error_t	database_delete_session (sqlite3 *db, const uint8_t session_id[16])
	Delete session from database.
void	database_close (sqlite3 *db)
	Close database.

Detailed Description

💾 SQLite persistence implementation

Provides SQLite persistence for sessions, participants, and rate limiting. Sessions are saved on creation and loaded on startup for crash recovery.

RCU Integration:

• Session loading uses RCU lock-free hash table (cds_lfht)
• No global locks needed - RCU read-side provides synchronization

Definition in file database.c.

Function Documentation

database_close()

void database_close

(

sqlite3 *

db

)

Close database.

Parameters

db	Database handle to close

Definition at line 339 of file database.c.

                                 {
  if (!db) {
    return;
  }
 
  sqlite3_close(db);
  log_debug("Database closed");
}

References log_debug.

Referenced by acds_server_init(), and acds_server_shutdown().

database_delete_session()

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

Delete session from database.

Parameters

db	Database handle
session_id	Session UUID

Returns

ASCIICHAT_OK on success, error code otherwise

Definition at line 313 of file database.c.

                                                                                     {
  if (!db || !session_id) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "db or session_id is NULL");
  }
 
  const char *sql = "DELETE FROM sessions WHERE session_id = ?";
 
  sqlite3_stmt *stmt = NULL;
  int rc = sqlite3_prepare_v2(db, sql, -1, &stmt, NULL);
  if (rc != SQLITE_OK) {
    return SET_ERRNO(ERROR_CONFIG, "Failed to prepare session delete query: %s", sqlite3_errmsg(db));
  }
 
  sqlite3_bind_blob(stmt, 1, session_id, 16, SQLITE_STATIC);
 
  rc = sqlite3_step(stmt);
  sqlite3_finalize(stmt);
 
  if (rc != SQLITE_DONE) {
    return SET_ERRNO(ERROR_CONFIG, "Failed to delete session: %s", sqlite3_errmsg(db));
  }
 
  log_debug("Session deleted from database");
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ERROR_CONFIG, ERROR_INVALID_PARAM, log_debug, session_id, and SET_ERRNO.

database_init()

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

Initialize database and create schema.

Parameters

db_path	Path to SQLite database file
db	Output database handle

Returns

ASCIICHAT_OK on success, error code otherwise

Definition at line 58 of file database.c.

                                                                   {
  if (!db_path || !db) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "db_path or db is NULL");
  }
 
  log_info("Opening database: %s", db_path);
 
  // Open database
  int rc = sqlite3_open(db_path, db);
  if (rc != SQLITE_OK) {
    const char *err = sqlite3_errmsg(*db);
    sqlite3_close(*db);
    *db = NULL;
    return SET_ERRNO(ERROR_CONFIG, "Failed to open database: %s", err);
  }
 
  // Enable Write-Ahead Logging for better concurrency
  char *err_msg = NULL;
  rc = sqlite3_exec(*db, "PRAGMA journal_mode=WAL;", NULL, NULL, &err_msg);
  if (rc != SQLITE_OK) {
    log_warn("Failed to enable WAL mode: %s", err_msg ? err_msg : "unknown error");
    sqlite3_free(err_msg);
  }
 
  // Enable foreign key constraints
  rc = sqlite3_exec(*db, "PRAGMA foreign_keys=ON;", NULL, NULL, &err_msg);
  if (rc != SQLITE_OK) {
    log_error("Failed to enable foreign keys: %s", err_msg ? err_msg : "unknown error");
    sqlite3_free(err_msg);
    sqlite3_close(*db);
    *db = NULL;
    return SET_ERRNO(ERROR_CONFIG, "Failed to enable foreign keys");
  }
 
  // Create schema
  rc = sqlite3_exec(*db, schema_sql, NULL, NULL, &err_msg);
  if (rc != SQLITE_OK) {
    log_error("Failed to create schema: %s", err_msg ? err_msg : "unknown error");
    sqlite3_free(err_msg);
    sqlite3_close(*db);
    *db = NULL;
    return SET_ERRNO(ERROR_CONFIG, "Failed to create database schema");
  }
 
  log_info("Database initialized successfully");
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ERROR_CONFIG, ERROR_INVALID_PARAM, log_error, log_info, log_warn, and SET_ERRNO.

Referenced by acds_server_init().

database_load_sessions()

asciichat_error_t database_load_sessions	(	sqlite3 *	db,
		session_registry_t *	registry
	)

Load active sessions from database into registry.

Parameters

db	Database handle
registry	Session registry to populate

Returns

ASCIICHAT_OK on success, error code otherwise

Definition at line 106 of file database.c.

                                                                                    {
  if (!db || !registry) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "db or registry is NULL");
  }
 
  // Get current time
  struct timespec ts;
  clock_gettime(CLOCK_REALTIME, &ts);
  uint64_t now = (uint64_t)ts.tv_sec * 1000 + (uint64_t)ts.tv_nsec / 1000000;
 
  // Prepare statement to load non-expired sessions
  const char *sql = "SELECT session_id, session_string, host_pubkey, password_hash, "
                    "max_participants, capabilities, created_at, expires_at "
                    "FROM sessions WHERE expires_at > ?";
 
  sqlite3_stmt *stmt = NULL;
  int rc = sqlite3_prepare_v2(db, sql, -1, &stmt, NULL);
  if (rc != SQLITE_OK) {
    return SET_ERRNO(ERROR_CONFIG, "Failed to prepare session load query: %s", sqlite3_errmsg(db));
  }
 
  sqlite3_bind_int64(stmt, 1, (sqlite3_int64)now);
 
  size_t loaded_count = 0;
 
  // Iterate through sessions
  while ((rc = sqlite3_step(stmt)) == SQLITE_ROW) {
    // Allocate session entry
    session_entry_t *session = SAFE_MALLOC(sizeof(session_entry_t), session_entry_t *);
    if (!session) {
      sqlite3_finalize(stmt);
      return SET_ERRNO(ERROR_MEMORY, "Failed to allocate session entry");
    }
 
    memset(session, 0, sizeof(*session));
 
    // Load session data
    memcpy(session->session_id, sqlite3_column_blob(stmt, 0), 16);
    const char *session_string = (const char *)sqlite3_column_text(stmt, 1);
    SAFE_STRNCPY(session->session_string, session_string, sizeof(session->session_string));
    memcpy(session->host_pubkey, sqlite3_column_blob(stmt, 2), 32);
 
    const char *password_hash = (const char *)sqlite3_column_text(stmt, 3);
    if (password_hash) {
      SAFE_STRNCPY(session->password_hash, password_hash, sizeof(session->password_hash));
      session->has_password = true;
    } else {
      session->has_password = false;
    }
 
    session->max_participants = (uint8_t)sqlite3_column_int(stmt, 4);
    session->capabilities = (uint8_t)sqlite3_column_int(stmt, 5);
    session->created_at = (uint64_t)sqlite3_column_int64(stmt, 6);
    session->expires_at = (uint64_t)sqlite3_column_int64(stmt, 7);
    session->current_participants = 0; // Will be updated when loading participants
 
    // Load participants for this session
    sqlite3_stmt *part_stmt = NULL;
    const char *part_sql = "SELECT participant_id, identity_pubkey, joined_at "
                           "FROM participants WHERE session_id = ?";
 
    rc = sqlite3_prepare_v2(db, part_sql, -1, &part_stmt, NULL);
    if (rc == SQLITE_OK) {
      sqlite3_bind_blob(part_stmt, 1, session->session_id, 16, SQLITE_STATIC);
 
      size_t part_idx = 0;
      while ((rc = sqlite3_step(part_stmt)) == SQLITE_ROW && part_idx < MAX_PARTICIPANTS) {
        participant_t *participant = SAFE_MALLOC(sizeof(participant_t), participant_t *);
        if (participant) {
          memcpy(participant->participant_id, sqlite3_column_blob(part_stmt, 0), 16);
          memcpy(participant->identity_pubkey, sqlite3_column_blob(part_stmt, 1), 32);
          participant->joined_at = (uint64_t)sqlite3_column_int64(part_stmt, 2);
 
          session->participants[part_idx] = participant;
          session->current_participants++;
          part_idx++;
        }
      }
 
      sqlite3_finalize(part_stmt);
    }
 
    /* Add to RCU hash table (no lock needed)
       RCU provides automatic synchronization for concurrent readers */
    unsigned long hash = 5381; // DJB2 hash
    const char *str = session->session_string;
    int c;
    while ((c = (unsigned char)*str++)) {
      hash = ((hash << 5) + hash) + c;
    }
 
    cds_lfht_node_init(&session->hash_node);
    struct cds_lfht_node *ret_node = cds_lfht_add_unique(registry->sessions, hash,
                                                         /* match callback */
                                                         NULL, // Using NULL match for now (will use default equality)
                                                         session->session_string, &session->hash_node);
 
    if (ret_node != &session->hash_node) {
      /* Session already exists - free this duplicate */
      for (size_t i = 0; i < MAX_PARTICIPANTS; i++) {
        SAFE_FREE(session->participants[i]);
      }
      SAFE_FREE(session);
      log_warn("Duplicate session in database: %s (skipping)", session_string);
      continue;
    }
 
    loaded_count++;
  }
 
  sqlite3_finalize(stmt);
 
  if (rc != SQLITE_DONE) {
    log_warn("Session loading ended with status %d: %s", rc, sqlite3_errmsg(db));
  }
 
  log_info("Loaded %zu sessions from database", loaded_count);
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, session_entry::capabilities, session_entry::created_at, session_entry::current_participants, ERROR_CONFIG, ERROR_INVALID_PARAM, ERROR_MEMORY, session_entry::expires_at, session_entry::has_password, session_entry::hash_node, session_entry::host_pubkey, participant_t::identity_pubkey, participant_t::joined_at, log_info, log_warn, MAX_PARTICIPANTS, session_entry::max_participants, participant_t::participant_id, session_entry::participants, session_entry::password_hash, SAFE_FREE, SAFE_MALLOC, SAFE_STRNCPY, session_entry::session_id, session_entry::session_string, session_registry_t::sessions, and SET_ERRNO.

Referenced by acds_server_init().

database_save_session()

asciichat_error_t database_save_session	(	sqlite3 *	db,
		const session_entry_t *	session
	)

Save session to database.

Parameters

db	Database handle
session	Session entry to save

Returns

ASCIICHAT_OK on success, error code otherwise

Definition at line 226 of file database.c.

                                                                                     {
  if (!db || !session) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "db or session is NULL");
  }
 
  // Begin transaction
  char *err_msg = NULL;
  int rc = sqlite3_exec(db, "BEGIN TRANSACTION;", NULL, NULL, &err_msg);
  if (rc != SQLITE_OK) {
    log_error("Failed to begin transaction: %s", err_msg ? err_msg : "unknown error");
    sqlite3_free(err_msg);
    return SET_ERRNO(ERROR_CONFIG, "Failed to begin transaction");
  }
 
  // Insert or replace session
  const char *sql = "INSERT OR REPLACE INTO sessions "
                    "(session_id, session_string, host_pubkey, password_hash, "
                    "max_participants, capabilities, created_at, expires_at) "
                    "VALUES (?, ?, ?, ?, ?, ?, ?, ?)";
 
  sqlite3_stmt *stmt = NULL;
  rc = sqlite3_prepare_v2(db, sql, -1, &stmt, NULL);
  if (rc != SQLITE_OK) {
    sqlite3_exec(db, "ROLLBACK;", NULL, NULL, NULL);
    return SET_ERRNO(ERROR_CONFIG, "Failed to prepare session save query: %s", sqlite3_errmsg(db));
  }
 
  sqlite3_bind_blob(stmt, 1, session->session_id, 16, SQLITE_STATIC);
  sqlite3_bind_text(stmt, 2, session->session_string, -1, SQLITE_STATIC);
  sqlite3_bind_blob(stmt, 3, session->host_pubkey, 32, SQLITE_STATIC);
  sqlite3_bind_text(stmt, 4, session->has_password ? session->password_hash : NULL, -1, SQLITE_STATIC);
  sqlite3_bind_int(stmt, 5, session->max_participants);
  sqlite3_bind_int(stmt, 6, session->capabilities);
  sqlite3_bind_int64(stmt, 7, (sqlite3_int64)session->created_at);
  sqlite3_bind_int64(stmt, 8, (sqlite3_int64)session->expires_at);
 
  rc = sqlite3_step(stmt);
  sqlite3_finalize(stmt);
 
  if (rc != SQLITE_DONE) {
    sqlite3_exec(db, "ROLLBACK;", NULL, NULL, NULL);
    return SET_ERRNO(ERROR_CONFIG, "Failed to save session: %s", sqlite3_errmsg(db));
  }
 
  // Delete old participants (will re-insert current ones)
  const char *del_sql = "DELETE FROM participants WHERE session_id = ?";
  rc = sqlite3_prepare_v2(db, del_sql, -1, &stmt, NULL);
  if (rc == SQLITE_OK) {
    sqlite3_bind_blob(stmt, 1, session->session_id, 16, SQLITE_STATIC);
    sqlite3_step(stmt);
    sqlite3_finalize(stmt);
  }
 
  // Insert participants
  const char *part_sql = "INSERT INTO participants (participant_id, session_id, identity_pubkey, joined_at) "
                         "VALUES (?, ?, ?, ?)";
 
  for (size_t i = 0; i < MAX_PARTICIPANTS; i++) {
    if (session->participants[i]) {
      rc = sqlite3_prepare_v2(db, part_sql, -1, &stmt, NULL);
      if (rc != SQLITE_OK) {
        continue;
      }
 
      sqlite3_bind_blob(stmt, 1, session->participants[i]->participant_id, 16, SQLITE_STATIC);
      sqlite3_bind_blob(stmt, 2, session->session_id, 16, SQLITE_STATIC);
      sqlite3_bind_blob(stmt, 3, session->participants[i]->identity_pubkey, 32, SQLITE_STATIC);
      sqlite3_bind_int64(stmt, 4, (sqlite3_int64)session->participants[i]->joined_at);
 
      sqlite3_step(stmt);
      sqlite3_finalize(stmt);
    }
  }
 
  // Commit transaction
  rc = sqlite3_exec(db, "COMMIT;", NULL, NULL, &err_msg);
  if (rc != SQLITE_OK) {
    log_error("Failed to commit transaction: %s", err_msg ? err_msg : "unknown error");
    sqlite3_free(err_msg);
    sqlite3_exec(db, "ROLLBACK;", NULL, NULL, NULL);
    return SET_ERRNO(ERROR_CONFIG, "Failed to commit transaction");
  }
 
  log_debug("Session %s saved to database", session->session_string);
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, session_entry::capabilities, session_entry::created_at, ERROR_CONFIG, ERROR_INVALID_PARAM, session_entry::expires_at, session_entry::has_password, session_entry::host_pubkey, participant_t::identity_pubkey, participant_t::joined_at, log_debug, log_error, MAX_PARTICIPANTS, session_entry::max_participants, participant_t::participant_id, session_entry::participants, session_entry::password_hash, session_entry::session_id, session_entry::session_string, and SET_ERRNO.