db.c File Reference

Autocrypt database handling. More...

#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"

Include dependency graph for db.c:

Go to the source code of this file.

Functions
static int	autocrypt_db_create (const char *db_path)
	Create an Autocrypt SQLite database.
int	mutt_autocrypt_db_init (bool can_create)
	Initialise the Autocrypt SQLite database.
void	mutt_autocrypt_db_close (struct AutocryptModuleData *mod_data)
	Close the Autocrypt SQLite database connection.
void	mutt_autocrypt_db_normalize_addr (struct Address *a)
	Normalise an Email Address.
void	mutt_autocrypt_db_normalize_addrlist (struct AddressList *al)
	Normalise a list of Email Addresses.
static struct Address *	copy_normalize_addr (struct Address *addr)
	Copy a normalised Email Address.
static char *	strdup_column_text (sqlite3_stmt *stmt, int index)
	Copy a string from the database.
struct AutocryptAccount *	mutt_autocrypt_db_account_new (void)
	Create a new AutocryptAccount.
void	mutt_autocrypt_db_account_free (struct AutocryptAccount **ptr)
	Free an AutocryptAccount.
int	mutt_autocrypt_db_account_get (struct Address *addr, struct AutocryptAccount **account)
	Get Autocrypt Account data from the database.
int	mutt_autocrypt_db_account_insert (struct Address *addr, const char *keyid, const char *keydata, bool prefer_encrypt)
	Insert an Account into the Autocrypt database.
int	mutt_autocrypt_db_account_update (struct AutocryptAccount *acct)
	Update Account info in the Autocrypt database.
int	mutt_autocrypt_db_account_delete (struct AutocryptAccount *acct)
	Delete an Account from the Autocrypt database.
int	mutt_autocrypt_db_account_get_all (struct AutocryptAccountArray *aaa)
	Get all accounts from an Autocrypt database.
struct AutocryptPeer *	mutt_autocrypt_db_peer_new (void)
	Create a new AutocryptPeer.
void	mutt_autocrypt_db_peer_free (struct AutocryptPeer **ptr)
	Free an AutocryptPeer.
int	mutt_autocrypt_db_peer_get (struct Address *addr, struct AutocryptPeer **peer)
	Get peer info from the Autocrypt database.
int	mutt_autocrypt_db_peer_insert (struct Address *addr, struct AutocryptPeer *peer)
	Insert a peer into the Autocrypt database.
int	mutt_autocrypt_db_peer_update (struct AutocryptPeer *peer)
	Update the peer info in an Autocrypt database.
struct AutocryptPeerHistory *	mutt_autocrypt_db_peer_history_new (void)
	Create a new AutocryptPeerHistory.
void	mutt_autocrypt_db_peer_history_free (struct AutocryptPeerHistory **ptr)
	Free an AutocryptPeerHistory.
int	mutt_autocrypt_db_peer_history_insert (struct Address *addr, struct AutocryptPeerHistory *peerhist)
	Insert peer history into the Autocrypt database.
struct AutocryptGossipHistory *	mutt_autocrypt_db_gossip_history_new (void)
	Create a new AutocryptGossipHistory.
void	mutt_autocrypt_db_gossip_history_free (struct AutocryptGossipHistory **ptr)
	Free an AutocryptGossipHistory.
int	mutt_autocrypt_db_gossip_history_insert (struct Address *addr, struct AutocryptGossipHistory *gossip_hist)
	Insert a gossip history into the Autocrypt database.

Detailed Description

Autocrypt database handling.

Authors

• Kevin J. McCarthy
• Richard Russon
• Pietro Cerutti
• Anna Figueiredo Gomes

Copyright

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Definition in file db.c.

Function Documentation

autocrypt_db_create()

static int autocrypt_db_create ( const char * db_path )

static

Create an Autocrypt SQLite database.

Parameters

db_path

Path to database file

Return values

0	Success
-1	Error

Definition at line 51 of file db.c.

{
  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();
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_autocrypt_db_init()

int mutt_autocrypt_db_init

(

bool

can_create

)

Initialise the Autocrypt SQLite database.

Parameters

can_create

If true, the directory may be created

Return values

0	Success
-1	Error

Definition at line 73 of file db.c.

{
  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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_autocrypt_db_close()

void mutt_autocrypt_db_close

(

struct AutocryptModuleData *

mod_data

)

Close the Autocrypt SQLite database connection.

Parameters

mod_data

Autocrypt module data

Definition at line 127 of file db.c.

{
  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;
}

Here is the caller graph for this function:

mutt_autocrypt_db_normalize_addr()

void mutt_autocrypt_db_normalize_addr

(

struct Address *

a

)

Normalise an Email Address.

Parameters

a	Address to normalise

Definition at line 162 of file db.c.

{
  mutt_addr_to_local(a);
  buf_lower(a->mailbox);
  mutt_addr_to_intl(a);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_autocrypt_db_normalize_addrlist()

void mutt_autocrypt_db_normalize_addrlist

(

struct AddressList *

al

)

Normalise a list of Email Addresses.

Parameters

al	List of Addresses to normalise

Definition at line 173 of file db.c.

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

Here is the call graph for this function:

Here is the caller graph for this function:

copy_normalize_addr()

static struct Address * copy_normalize_addr ( struct Address * addr )

static

Copy a normalised Email Address.

Parameters

addr	Address to normalise and copy

Return values

ptr	Copy of the Address

The autocrypt spec says email addresses should be normalized to lower case and stored in idna form.

In order to avoid visible changes to addresses in the index, we make a copy of the address before lowercasing it.

Note

The return value must be freed

Definition at line 199 of file db.c.

{
  /* 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

strdup_column_text()

static char * strdup_column_text ( sqlite3_stmt * stmt, int index )

static

Copy a string from the database.

Parameters

stmt	SQLite database statement
index	Database row

Return values

ptr	Copy of string

Definition at line 221 of file db.c.

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

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_autocrypt_db_account_new()

struct AutocryptAccount * mutt_autocrypt_db_account_new

(

void

)

Create a new AutocryptAccount.

Return values

ptr	New AutocryptAccount

Definition at line 231 of file db.c.

{
  return MUTT_MEM_CALLOC(1, struct AutocryptAccount);
}

Here is the caller graph for this function:

mutt_autocrypt_db_account_free()

void mutt_autocrypt_db_account_free

(

struct AutocryptAccount **

ptr

)

Free an AutocryptAccount.

Parameters

ptr	Account to free

Definition at line 240 of file db.c.

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

Here is the caller graph for this function:

mutt_autocrypt_db_account_get()

int mutt_autocrypt_db_account_get	(	struct Address *	addr,
		struct AutocryptAccount **	account )

Get Autocrypt Account data from the database.

Parameters

[in]	addr	Email Address to lookup
[out]	account	Matched account

Return values

0	Success
-1	Error

Definition at line 259 of file db.c.

{
  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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_autocrypt_db_account_insert()

int mutt_autocrypt_db_account_insert	(	struct Address *	addr,
		const char *	keyid,
		const char *	keydata,
		bool	prefer_encrypt )

Insert an Account into the Autocrypt database.

Parameters

addr	Email Address for the account
keyid	Autocrypt KeyID
keydata	Autocrypt key data
prefer_encrypt	Whether the account prefers encryption

Return values

0	Success
-1	Error

Definition at line 325 of file db.c.

{
  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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_autocrypt_db_account_update()

int mutt_autocrypt_db_account_update

(

struct AutocryptAccount *

acct

)

Update Account info in the Autocrypt database.

Parameters

acct	Autocrypt Account data

Return values

0	Success
-1	Error

Definition at line 383 of file db.c.

{
  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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_autocrypt_db_account_delete()

int mutt_autocrypt_db_account_delete

(

struct AutocryptAccount *

acct

)

Delete an Account from the Autocrypt database.

Parameters

acct	Account to delete

Return values

0	Success
-1	Error

Definition at line 434 of file db.c.

{
  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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_autocrypt_db_account_get_all()

int mutt_autocrypt_db_account_get_all

(

struct AutocryptAccountArray *

aaa

)

Get all accounts from an Autocrypt database.

Parameters

aaa	Account array

Return values

n	Success, number of Accounts
-1	Error

Definition at line 473 of file db.c.

{
  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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_autocrypt_db_peer_new()

struct AutocryptPeer * mutt_autocrypt_db_peer_new

(

void

)

Create a new AutocryptPeer.

Return values

ptr	New AutocryptPeer

Definition at line 537 of file db.c.

{
  return MUTT_MEM_CALLOC(1, struct AutocryptPeer);
}

Here is the caller graph for this function:

mutt_autocrypt_db_peer_free()

void mutt_autocrypt_db_peer_free

(

struct AutocryptPeer **

ptr

)

Free an AutocryptPeer.

Parameters

ptr	AutocryptPeer to free

Definition at line 546 of file db.c.

{
  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);
}

Here is the caller graph for this function:

mutt_autocrypt_db_peer_get()

int mutt_autocrypt_db_peer_get	(	struct Address *	addr,
		struct AutocryptPeer **	peer )

Get peer info from the Autocrypt database.

Parameters

[in]	addr	Email Address to look up
[out]	peer	Matching Autocrypt Peer

Return values

0	Success, no matches
1	Success, a match
-1	Error

Definition at line 568 of file db.c.

{
  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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_autocrypt_db_peer_insert()

int mutt_autocrypt_db_peer_insert	(	struct Address *	addr,
		struct AutocryptPeer *	peer )

Insert a peer into the Autocrypt database.

Parameters

addr	Email Address
peer	AutocryptPeer to insert

Return values

0	Success
-1	Error

Definition at line 640 of file db.c.

{
  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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_autocrypt_db_peer_update()

int mutt_autocrypt_db_peer_update

(

struct AutocryptPeer *

peer

)

Update the peer info in an Autocrypt database.

Parameters

peer	AutocryptPeer to update

Return values

0	Success
-1	Error

Definition at line 710 of file db.c.

{
  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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_autocrypt_db_peer_history_new()

struct AutocryptPeerHistory * mutt_autocrypt_db_peer_history_new

(

void

)

Create a new AutocryptPeerHistory.

Return values

ptr	New AutocryptPeerHistory

Definition at line 771 of file db.c.

{
  return MUTT_MEM_CALLOC(1, struct AutocryptPeerHistory);
}

Here is the caller graph for this function:

mutt_autocrypt_db_peer_history_free()

void mutt_autocrypt_db_peer_history_free

(

struct AutocryptPeerHistory **

ptr

)

Free an AutocryptPeerHistory.

Parameters

ptr	AutocryptPeerHistory to free

Definition at line 780 of file db.c.

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

Here is the caller graph for this function:

mutt_autocrypt_db_peer_history_insert()

int mutt_autocrypt_db_peer_history_insert	(	struct Address *	addr,
		struct AutocryptPeerHistory *	peerhist )

Insert peer history into the Autocrypt database.

Parameters

addr	Email Address
peerhist	Peer history to insert

Return values

0	Success
-1	Error

Definition at line 799 of file db.c.

{
  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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_autocrypt_db_gossip_history_new()

struct AutocryptGossipHistory * mutt_autocrypt_db_gossip_history_new

(

void

)

Create a new AutocryptGossipHistory.

Return values

ptr	New AutocryptGossipHistory

Definition at line 854 of file db.c.

{
  return MUTT_MEM_CALLOC(1, struct AutocryptGossipHistory);
}

Here is the caller graph for this function:

mutt_autocrypt_db_gossip_history_free()

void mutt_autocrypt_db_gossip_history_free

(

struct AutocryptGossipHistory **

ptr

)

Free an AutocryptGossipHistory.

Parameters

ptr	AutocryptGossipHistory to free

Definition at line 863 of file db.c.

{
  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);
}

Here is the caller graph for this function:

mutt_autocrypt_db_gossip_history_insert()

int mutt_autocrypt_db_gossip_history_insert	(	struct Address *	addr,
		struct AutocryptGossipHistory *	gossip_hist )

Insert a gossip history into the Autocrypt database.

Parameters

addr	Email Address
gossip_hist	Gossip history to insert

Return values

0	Success
-1	Error

Definition at line 883 of file db.c.

{
  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;
}

Here is the call graph for this function:

Here is the caller graph for this function: