db.c

Go to the documentation of this file.

 
#include "config.h"
#include <sqlite3.h>
#include <stdbool.h>
#include <stddef.h>
#include <sys/stat.h>
#include "private.h"
#include "mutt/lib.h"
#include "address/lib.h"
#include "config/lib.h"
#include "core/lib.h"
#include "lib.h"
#include "module_data.h"

static int autocrypt_db_create(const char *db_path)
{
  struct AutocryptModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_AUTOCRYPT);
  sqlite3 *db = NULL;
 
  if (sqlite3_open_v2(db_path, &db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL) != SQLITE_OK)
  {
    /* L10N: autocrypt couldn't open the SQLite database.
             The %s is the full path of the database file.  */
    mutt_error(_("Unable to open autocrypt database %s"), db_path);
    return -1;
  }
  mod_data->autocrypt_db = db;
  return mutt_autocrypt_schema_init();
}

int mutt_autocrypt_db_init(bool can_create)
{
  int rc = -1;
  struct AutocryptModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_AUTOCRYPT);
 
  if (mod_data->autocrypt_db)
    return 0;
 
  const bool c_autocrypt = cs_subset_bool(NeoMutt->sub, "autocrypt");
  const char *const c_autocrypt_dir = cs_subset_path(NeoMutt->sub, "autocrypt_dir");
  if (!c_autocrypt || !c_autocrypt_dir)
    return -1;
 
  struct Buffer *db_path = buf_pool_get();
  buf_concat_path(db_path, c_autocrypt_dir, "autocrypt.db");
 
  struct stat st = { 0 };
  if (stat(buf_string(db_path), &st) == 0)
  {
    sqlite3 *db = NULL;
    if (sqlite3_open_v2(buf_string(db_path), &db, SQLITE_OPEN_READWRITE, NULL) != SQLITE_OK)
    {
      /* L10N: autocrypt couldn't open the SQLite database.
               The %s is the full path of the database file.  */
      mutt_error(_("Unable to open autocrypt database %s"), buf_string(db_path));
      goto cleanup;
    }
    mod_data->autocrypt_db = db;
 
    if (mutt_autocrypt_schema_update())
      goto cleanup;
  }
  else
  {
    if (!can_create)
      goto cleanup;
    if (autocrypt_db_create(buf_string(db_path)))
      goto cleanup;
    /* Don't abort the whole init process because account creation failed */
    mutt_autocrypt_account_init(true);
    mutt_autocrypt_scan_mailboxes();
  }
 
  rc = 0;
 
cleanup:
  buf_pool_release(&db_path);
  return rc;
}

void mutt_autocrypt_db_close(struct AutocryptModuleData *mod_data)
{
  if (!mod_data->autocrypt_db)
    return;
 
  sqlite3_finalize(mod_data->account_get_stmt);
  mod_data->account_get_stmt = NULL;
  sqlite3_finalize(mod_data->account_insert_stmt);
  mod_data->account_insert_stmt = NULL;
  sqlite3_finalize(mod_data->account_update_stmt);
  mod_data->account_update_stmt = NULL;
  sqlite3_finalize(mod_data->account_delete_stmt);
  mod_data->account_delete_stmt = NULL;
 
  sqlite3_finalize(mod_data->peer_get_stmt);
  mod_data->peer_get_stmt = NULL;
  sqlite3_finalize(mod_data->peer_insert_stmt);
  mod_data->peer_insert_stmt = NULL;
  sqlite3_finalize(mod_data->peer_update_stmt);
  mod_data->peer_update_stmt = NULL;
 
  sqlite3_finalize(mod_data->peer_history_insert_stmt);
  mod_data->peer_history_insert_stmt = NULL;
 
  sqlite3_finalize(mod_data->gossip_history_insert_stmt);
  mod_data->gossip_history_insert_stmt = NULL;
 
  sqlite3_close_v2(mod_data->autocrypt_db);
  mod_data->autocrypt_db = NULL;
}

void mutt_autocrypt_db_normalize_addr(struct Address *a)
{
  mutt_addr_to_local(a);
  buf_lower(a->mailbox);
  mutt_addr_to_intl(a);
}

void mutt_autocrypt_db_normalize_addrlist(struct AddressList *al)
{
  mutt_addrlist_to_local(al);
 
  struct Address *np = NULL;
  TAILQ_FOREACH(np, al, entries)
  {
    buf_lower(np->mailbox);
  }
 
  mutt_addrlist_to_intl(al, NULL);
}

static struct Address *copy_normalize_addr(struct Address *addr)
{
  /* NOTE: the db functions expect a single address, so in
   * this function we copy only the address passed in.
   *
   * The normalize_addrlist above is extended to work on a list
   * because of requirements in autocrypt.c */
 
  struct Address *norm_addr = mutt_addr_create(NULL, buf_string(addr->mailbox));
  norm_addr->is_intl = addr->is_intl;
  norm_addr->intl_checked = addr->intl_checked;
 
  mutt_autocrypt_db_normalize_addr(norm_addr);
  return norm_addr;
}

static char *strdup_column_text(sqlite3_stmt *stmt, int index)
{
  const char *val = (const char *) sqlite3_column_text(stmt, index);
  return mutt_str_dup(val);
}

struct AutocryptAccount *mutt_autocrypt_db_account_new(void)
{
  return MUTT_MEM_CALLOC(1, struct AutocryptAccount);
}

void mutt_autocrypt_db_account_free(struct AutocryptAccount **ptr)
{
  if (!ptr || !*ptr)
    return;
 
  struct AutocryptAccount *ac = *ptr;
  FREE(&ac->email_addr);
  FREE(&ac->keyid);
  FREE(&ac->keydata);
  FREE(ptr);
}

int mutt_autocrypt_db_account_get(struct Address *addr, struct AutocryptAccount **account)
{
  int rc = -1;
 
  struct AutocryptModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_AUTOCRYPT);
  sqlite3 *db = mod_data->autocrypt_db;
  sqlite3_stmt *stmt = mod_data->account_get_stmt;
 
  struct Address *norm_addr = copy_normalize_addr(addr);
  *account = NULL;
 
  if (!stmt)
  {
    if (sqlite3_prepare_v3(db,
                           "SELECT "
                           "email_addr, "
                           "keyid, "
                           "keydata, "
                           "prefer_encrypt, "
                           "enabled "
                           "FROM account "
                           "WHERE email_addr = ?",
                           -1, SQLITE_PREPARE_PERSISTENT, &stmt, NULL) != SQLITE_OK)
    {
      goto cleanup;
    }
    mod_data->account_get_stmt = stmt;
  }
 
  if (sqlite3_bind_text(stmt, 1, buf_string(norm_addr->mailbox), -1, SQLITE_STATIC) != SQLITE_OK)
  {
    goto cleanup;
  }
 
  int result = sqlite3_step(stmt);
  if (result != SQLITE_ROW)
  {
    if (result == SQLITE_DONE)
      rc = 0;
    goto cleanup;
  }
 
  *account = mutt_autocrypt_db_account_new();
  (*account)->email_addr = strdup_column_text(stmt, 0);
  (*account)->keyid = strdup_column_text(stmt, 1);
  (*account)->keydata = strdup_column_text(stmt, 2);
  (*account)->prefer_encrypt = sqlite3_column_int(stmt, 3);
  (*account)->enabled = sqlite3_column_int(stmt, 4);
 
  rc = 1;
 
cleanup:
  mutt_addr_free(&norm_addr);
  sqlite3_reset(stmt);
  return rc;
}

int mutt_autocrypt_db_account_insert(struct Address *addr, const char *keyid,
                                     const char *keydata, bool prefer_encrypt)
{
  int rc = -1;
 
  struct AutocryptModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_AUTOCRYPT);
  sqlite3 *db = mod_data->autocrypt_db;
  sqlite3_stmt *stmt = mod_data->account_insert_stmt;
 
  struct Address *norm_addr = copy_normalize_addr(addr);
 
  if (!stmt)
  {
    if (sqlite3_prepare_v3(db,
                           "INSERT INTO account "
                           "(email_addr, "
                           "keyid, "
                           "keydata, "
                           "prefer_encrypt, "
                           "enabled) "
                           "VALUES (?, ?, ?, ?, ?);",
                           -1, SQLITE_PREPARE_PERSISTENT, &stmt, NULL) != SQLITE_OK)
    {
      goto cleanup;
    }
    mod_data->account_insert_stmt = stmt;
  }
 
  if (sqlite3_bind_text(stmt, 1, buf_string(norm_addr->mailbox), -1, SQLITE_STATIC) != SQLITE_OK)
  {
    goto cleanup;
  }
  if (sqlite3_bind_text(stmt, 2, keyid, -1, SQLITE_STATIC) != SQLITE_OK)
    goto cleanup;
  if (sqlite3_bind_text(stmt, 3, keydata, -1, SQLITE_STATIC) != SQLITE_OK)
    goto cleanup;
  if (sqlite3_bind_int(stmt, 4, prefer_encrypt) != SQLITE_OK)
    goto cleanup;
  if (sqlite3_bind_int(stmt, 5, 1) != SQLITE_OK)
    goto cleanup;
 
  if (sqlite3_step(stmt) != SQLITE_DONE)
    goto cleanup;
 
  rc = 0;
 
cleanup:
  mutt_addr_free(&norm_addr);
  sqlite3_reset(stmt);
  return rc;
}

int mutt_autocrypt_db_account_update(struct AutocryptAccount *acct)
{
  int rc = -1;
 
  struct AutocryptModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_AUTOCRYPT);
  sqlite3 *db = mod_data->autocrypt_db;
  sqlite3_stmt *stmt = mod_data->account_update_stmt;
 
  if (!stmt)
  {
    if (sqlite3_prepare_v3(db,
                           "UPDATE account SET "
                           "keyid = ?, "
                           "keydata = ?, "
                           "prefer_encrypt = ?, "
                           "enabled = ? "
                           "WHERE email_addr = ?;",
                           -1, SQLITE_PREPARE_PERSISTENT, &stmt, NULL) != SQLITE_OK)
    {
      goto cleanup;
    }
    mod_data->account_update_stmt = stmt;
  }
 
  if (sqlite3_bind_text(stmt, 1, acct->keyid, -1, SQLITE_STATIC) != SQLITE_OK)
    goto cleanup;
  if (sqlite3_bind_text(stmt, 2, acct->keydata, -1, SQLITE_STATIC) != SQLITE_OK)
    goto cleanup;
  if (sqlite3_bind_int(stmt, 3, acct->prefer_encrypt) != SQLITE_OK)
    goto cleanup;
  if (sqlite3_bind_int(stmt, 4, acct->enabled) != SQLITE_OK)
    goto cleanup;
  if (sqlite3_bind_text(stmt, 5, acct->email_addr, -1, SQLITE_STATIC) != SQLITE_OK)
    goto cleanup;
 
  if (sqlite3_step(stmt) != SQLITE_DONE)
    goto cleanup;
 
  rc = 0;
 
cleanup:
  sqlite3_reset(stmt);
  return rc;
}

int mutt_autocrypt_db_account_delete(struct AutocryptAccount *acct)
{
  int rc = -1;
 
  struct AutocryptModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_AUTOCRYPT);
  sqlite3 *db = mod_data->autocrypt_db;
  sqlite3_stmt *stmt = mod_data->account_delete_stmt;
 
  if (!stmt)
  {
    if (sqlite3_prepare_v3(db,
                           "DELETE from account "
                           "WHERE email_addr = ?;",
                           -1, SQLITE_PREPARE_PERSISTENT, &stmt, NULL) != SQLITE_OK)
    {
      goto cleanup;
    }
    mod_data->account_delete_stmt = stmt;
  }
 
  if (sqlite3_bind_text(stmt, 1, acct->email_addr, -1, SQLITE_STATIC) != SQLITE_OK)
    goto cleanup;
 
  if (sqlite3_step(stmt) != SQLITE_DONE)
    goto cleanup;
 
  rc = 0;
 
cleanup:
  sqlite3_reset(stmt);
  return rc;
}

int mutt_autocrypt_db_account_get_all(struct AutocryptAccountArray *aaa)
{
  if (!aaa)
    return -1;
 
  int rc = -1;
  sqlite3_stmt *stmt = NULL;
 
  struct AutocryptModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_AUTOCRYPT);
  sqlite3 *db = mod_data->autocrypt_db;
 
  /* Note, speed is not of the essence for the account management screen,
   * so we don't bother with a persistent prepared statement */
  if (sqlite3_prepare_v2(db,
                         "SELECT "
                         "email_addr, "
                         "keyid, "
                         "keydata, "
                         "prefer_encrypt, "
                         "enabled "
                         "FROM account "
                         "ORDER BY email_addr",
                         -1, &stmt, NULL) != SQLITE_OK)
  {
    goto cleanup;
  }
 
  int result = SQLITE_ERROR;
  while ((result = sqlite3_step(stmt)) == SQLITE_ROW)
  {
    struct AutocryptAccount *ac = mutt_autocrypt_db_account_new();
 
    ac->email_addr = strdup_column_text(stmt, 0);
    ac->keyid = strdup_column_text(stmt, 1);
    ac->keydata = strdup_column_text(stmt, 2);
    ac->prefer_encrypt = sqlite3_column_int(stmt, 3);
    ac->enabled = sqlite3_column_int(stmt, 4);
 
    ARRAY_ADD(aaa, ac);
  }
 
  if (result == SQLITE_DONE)
  {
    rc = ARRAY_SIZE(aaa);
  }
  else
  {
    struct AutocryptAccount **pac = NULL;
    ARRAY_FOREACH(pac, aaa)
    {
      mutt_autocrypt_db_account_free(pac);
    }
    ARRAY_FREE(aaa);
  }
 
cleanup:
  sqlite3_finalize(stmt);
  return rc;
}

struct AutocryptPeer *mutt_autocrypt_db_peer_new(void)
{
  return MUTT_MEM_CALLOC(1, struct AutocryptPeer);
}

void mutt_autocrypt_db_peer_free(struct AutocryptPeer **ptr)
{
  if (!ptr || !*ptr)
    return;
 
  struct AutocryptPeer *peer = *ptr;
  FREE(&peer->email_addr);
  FREE(&peer->keyid);
  FREE(&peer->keydata);
  FREE(&peer->gossip_keyid);
  FREE(&peer->gossip_keydata);
  FREE(ptr);
}

int mutt_autocrypt_db_peer_get(struct Address *addr, struct AutocryptPeer **peer)
{
  int rc = -1;
 
  struct AutocryptModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_AUTOCRYPT);
  sqlite3 *db = mod_data->autocrypt_db;
  sqlite3_stmt *stmt = mod_data->peer_get_stmt;
 
  struct Address *norm_addr = copy_normalize_addr(addr);
  *peer = NULL;
 
  if (!stmt)
  {
    if (sqlite3_prepare_v3(db,
                           "SELECT "
                           "email_addr, "
                           "last_seen, "
                           "autocrypt_timestamp, "
                           "keyid, "
                           "keydata, "
                           "prefer_encrypt, "
                           "gossip_timestamp, "
                           "gossip_keyid, "
                           "gossip_keydata "
                           "FROM peer "
                           "WHERE email_addr = ?",
                           -1, SQLITE_PREPARE_PERSISTENT, &stmt, NULL) != SQLITE_OK)
    {
      goto cleanup;
    }
    mod_data->peer_get_stmt = stmt;
  }
 
  if (sqlite3_bind_text(stmt, 1, buf_string(norm_addr->mailbox), -1, SQLITE_STATIC) != SQLITE_OK)
  {
    goto cleanup;
  }
 
  int result = sqlite3_step(stmt);
  if (result != SQLITE_ROW)
  {
    if (result == SQLITE_DONE)
      rc = 0;
    goto cleanup;
  }
 
  *peer = mutt_autocrypt_db_peer_new();
  (*peer)->email_addr = strdup_column_text(stmt, 0);
  (*peer)->last_seen = sqlite3_column_int64(stmt, 1);
  (*peer)->autocrypt_timestamp = sqlite3_column_int64(stmt, 2);
  (*peer)->keyid = strdup_column_text(stmt, 3);
  (*peer)->keydata = strdup_column_text(stmt, 4);
  (*peer)->prefer_encrypt = sqlite3_column_int(stmt, 5);
  (*peer)->gossip_timestamp = sqlite3_column_int64(stmt, 6);
  (*peer)->gossip_keyid = strdup_column_text(stmt, 7);
  (*peer)->gossip_keydata = strdup_column_text(stmt, 8);
 
  rc = 1;
 
cleanup:
  mutt_addr_free(&norm_addr);
  sqlite3_reset(stmt);
  return rc;
}

int mutt_autocrypt_db_peer_insert(struct Address *addr, struct AutocryptPeer *peer)
{
  int rc = -1;
  struct Address *norm_addr = NULL;
 
  struct AutocryptModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_AUTOCRYPT);
  sqlite3 *db = mod_data->autocrypt_db;
  sqlite3_stmt *stmt = mod_data->peer_insert_stmt;
 
  norm_addr = copy_normalize_addr(addr);
 
  if (!stmt)
  {
    if (sqlite3_prepare_v3(db,
                           "INSERT INTO peer "
                           "(email_addr, "
                           "last_seen, "
                           "autocrypt_timestamp, "
                           "keyid, "
                           "keydata, "
                           "prefer_encrypt, "
                           "gossip_timestamp, "
                           "gossip_keyid, "
                           "gossip_keydata) "
                           "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?);",
                           -1, SQLITE_PREPARE_PERSISTENT, &stmt, NULL) != SQLITE_OK)
    {
      goto cleanup;
    }
    mod_data->peer_insert_stmt = stmt;
  }
 
  if (sqlite3_bind_text(stmt, 1, buf_string(norm_addr->mailbox), -1, SQLITE_STATIC) != SQLITE_OK)
  {
    goto cleanup;
  }
  if (sqlite3_bind_int64(stmt, 2, peer->last_seen) != SQLITE_OK)
    goto cleanup;
  if (sqlite3_bind_int64(stmt, 3, peer->autocrypt_timestamp) != SQLITE_OK)
    goto cleanup;
  if (sqlite3_bind_text(stmt, 4, peer->keyid, -1, SQLITE_STATIC) != SQLITE_OK)
    goto cleanup;
  if (sqlite3_bind_text(stmt, 5, peer->keydata, -1, SQLITE_STATIC) != SQLITE_OK)
    goto cleanup;
  if (sqlite3_bind_int(stmt, 6, peer->prefer_encrypt) != SQLITE_OK)
    goto cleanup;
  if (sqlite3_bind_int64(stmt, 7, peer->gossip_timestamp) != SQLITE_OK)
    goto cleanup;
  if (sqlite3_bind_text(stmt, 8, peer->gossip_keyid, -1, SQLITE_STATIC) != SQLITE_OK)
    goto cleanup;
  if (sqlite3_bind_text(stmt, 9, peer->gossip_keydata, -1, SQLITE_STATIC) != SQLITE_OK)
    goto cleanup;
 
  if (sqlite3_step(stmt) != SQLITE_DONE)
    goto cleanup;
 
  rc = 0;
 
cleanup:
  mutt_addr_free(&norm_addr);
  sqlite3_reset(stmt);
  return rc;
}

int mutt_autocrypt_db_peer_update(struct AutocryptPeer *peer)
{
  int rc = -1;
 
  struct AutocryptModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_AUTOCRYPT);
  sqlite3 *db = mod_data->autocrypt_db;
  sqlite3_stmt *stmt = mod_data->peer_update_stmt;
 
  if (!stmt)
  {
    if (sqlite3_prepare_v3(db,
                           "UPDATE peer SET "
                           "last_seen = ?, "
                           "autocrypt_timestamp = ?, "
                           "keyid = ?, "
                           "keydata = ?, "
                           "prefer_encrypt = ?, "
                           "gossip_timestamp = ?, "
                           "gossip_keyid = ?, "
                           "gossip_keydata = ? "
                           "WHERE email_addr = ?;",
                           -1, SQLITE_PREPARE_PERSISTENT, &stmt, NULL) != SQLITE_OK)
    {
      goto cleanup;
    }
    mod_data->peer_update_stmt = stmt;
  }
 
  if (sqlite3_bind_int64(stmt, 1, peer->last_seen) != SQLITE_OK)
    goto cleanup;
  if (sqlite3_bind_int64(stmt, 2, peer->autocrypt_timestamp) != SQLITE_OK)
    goto cleanup;
  if (sqlite3_bind_text(stmt, 3, peer->keyid, -1, SQLITE_STATIC) != SQLITE_OK)
    goto cleanup;
  if (sqlite3_bind_text(stmt, 4, peer->keydata, -1, SQLITE_STATIC) != SQLITE_OK)
    goto cleanup;
  if (sqlite3_bind_int(stmt, 5, peer->prefer_encrypt) != SQLITE_OK)
    goto cleanup;
  if (sqlite3_bind_int64(stmt, 6, peer->gossip_timestamp) != SQLITE_OK)
    goto cleanup;
  if (sqlite3_bind_text(stmt, 7, peer->gossip_keyid, -1, SQLITE_STATIC) != SQLITE_OK)
    goto cleanup;
  if (sqlite3_bind_text(stmt, 8, peer->gossip_keydata, -1, SQLITE_STATIC) != SQLITE_OK)
    goto cleanup;
  if (sqlite3_bind_text(stmt, 9, peer->email_addr, -1, SQLITE_STATIC) != SQLITE_OK)
    goto cleanup;
 
  if (sqlite3_step(stmt) != SQLITE_DONE)
    goto cleanup;
 
  rc = 0;
 
cleanup:
  sqlite3_reset(stmt);
  return rc;
}

struct AutocryptPeerHistory *mutt_autocrypt_db_peer_history_new(void)
{
  return MUTT_MEM_CALLOC(1, struct AutocryptPeerHistory);
}

void mutt_autocrypt_db_peer_history_free(struct AutocryptPeerHistory **ptr)
{
  if (!ptr || !*ptr)
    return;
 
  struct AutocryptPeerHistory *ph = *ptr;
  FREE(&ph->peer_email_addr);
  FREE(&ph->email_msgid);
  FREE(&ph->keydata);
  FREE(ptr);
}

int mutt_autocrypt_db_peer_history_insert(struct Address *addr,
                                          struct AutocryptPeerHistory *peerhist)
{
  int rc = -1;
 
  struct AutocryptModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_AUTOCRYPT);
  sqlite3 *db = mod_data->autocrypt_db;
  sqlite3_stmt *stmt = mod_data->peer_history_insert_stmt;
 
  struct Address *norm_addr = copy_normalize_addr(addr);
 
  if (!stmt)
  {
    if (sqlite3_prepare_v3(db,
                           "INSERT INTO peer_history "
                           "(peer_email_addr, "
                           "email_msgid, "
                           "timestamp, "
                           "keydata) "
                           "VALUES (?, ?, ?, ?);",
                           -1, SQLITE_PREPARE_PERSISTENT, &stmt, NULL) != SQLITE_OK)
    {
      goto cleanup;
    }
    mod_data->peer_history_insert_stmt = stmt;
  }
 
  if (sqlite3_bind_text(stmt, 1, buf_string(norm_addr->mailbox), -1, SQLITE_STATIC) != SQLITE_OK)
  {
    goto cleanup;
  }
  if (sqlite3_bind_text(stmt, 2, peerhist->email_msgid, -1, SQLITE_STATIC) != SQLITE_OK)
  {
    goto cleanup;
  }
  if (sqlite3_bind_int64(stmt, 3, peerhist->timestamp) != SQLITE_OK)
    goto cleanup;
  if (sqlite3_bind_text(stmt, 4, peerhist->keydata, -1, SQLITE_STATIC) != SQLITE_OK)
    goto cleanup;
 
  if (sqlite3_step(stmt) != SQLITE_DONE)
    goto cleanup;
 
  rc = 0;
 
cleanup:
  mutt_addr_free(&norm_addr);
  sqlite3_reset(stmt);
  return rc;
}

struct AutocryptGossipHistory *mutt_autocrypt_db_gossip_history_new(void)
{
  return MUTT_MEM_CALLOC(1, struct AutocryptGossipHistory);
}

void mutt_autocrypt_db_gossip_history_free(struct AutocryptGossipHistory **ptr)
{
  if (!ptr || !*ptr)
    return;
 
  struct AutocryptGossipHistory *gh = *ptr;
  FREE(&gh->peer_email_addr);
  FREE(&gh->sender_email_addr);
  FREE(&gh->email_msgid);
  FREE(&gh->gossip_keydata);
  FREE(ptr);
}

int mutt_autocrypt_db_gossip_history_insert(struct Address *addr,
                                            struct AutocryptGossipHistory *gossip_hist)
{
  int rc = -1;
 
  struct AutocryptModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_AUTOCRYPT);
  sqlite3 *db = mod_data->autocrypt_db;
  sqlite3_stmt *stmt = mod_data->gossip_history_insert_stmt;
 
  struct Address *norm_addr = copy_normalize_addr(addr);
 
  if (!stmt)
  {
    if (sqlite3_prepare_v3(db,
                           "INSERT INTO gossip_history "
                           "(peer_email_addr, "
                           "sender_email_addr, "
                           "email_msgid, "
                           "timestamp, "
                           "gossip_keydata) "
                           "VALUES (?, ?, ?, ?, ?);",
                           -1, SQLITE_PREPARE_PERSISTENT, &stmt, NULL) != SQLITE_OK)
    {
      goto cleanup;
    }
    mod_data->gossip_history_insert_stmt = stmt;
  }
 
  if (sqlite3_bind_text(stmt, 1, buf_string(norm_addr->mailbox), -1, SQLITE_STATIC) != SQLITE_OK)
  {
    goto cleanup;
  }
  if (sqlite3_bind_text(stmt, 2, gossip_hist->sender_email_addr, -1, SQLITE_STATIC) != SQLITE_OK)
  {
    goto cleanup;
  }
  if (sqlite3_bind_text(stmt, 3, gossip_hist->email_msgid, -1, SQLITE_STATIC) != SQLITE_OK)
  {
    goto cleanup;
  }
  if (sqlite3_bind_int64(stmt, 4, gossip_hist->timestamp) != SQLITE_OK)
    goto cleanup;
  if (sqlite3_bind_text(stmt, 5, gossip_hist->gossip_keydata, -1, SQLITE_STATIC) != SQLITE_OK)
  {
    goto cleanup;
  }
 
  if (sqlite3_step(stmt) != SQLITE_DONE)
    goto cleanup;
 
  rc = 0;
 
cleanup:
  mutt_addr_free(&norm_addr);
  sqlite3_reset(stmt);
  return rc;
}