private.h File Reference

Shared constants/structs that are private to Autocrypt. More...

#include <sqlite3.h>
#include <stdbool.h>
#include "mutt/lib.h"

Include dependency graph for private.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	AccountEntry
	An entry in the Autocrypt account Menu. More...

Enumerations
enum	ExpandoDataAutocrypt {   ED_AUT_ENABLED = 1 , ED_AUT_KEYID , ED_AUT_ADDRESS , ED_AUT_NUMBER ,   ED_AUT_PREFER_ENCRYPT }
	Expando UIDs for Autocrypt. More...

Functions
	ARRAY_HEAD (AccountEntryArray, struct AccountEntry *)
int	mutt_autocrypt_account_init (bool prompt)
	Create a new Autocrypt account.
void	mutt_autocrypt_scan_mailboxes (void)
	Scan mailboxes for Autocrypt headers.
int	mutt_autocrypt_db_account_delete (struct AutocryptAccount *acct)
	Delete an Account from the Autocrypt database.
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_get_all (struct AutocryptAccountArray *aaa)
	Get all accounts from an Autocrypt 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.
struct AutocryptAccount *	mutt_autocrypt_db_account_new (void)
	Create a new AutocryptAccount.
int	mutt_autocrypt_db_account_update (struct AutocryptAccount *acct)
	Update Account info in the Autocrypt database.
void	mutt_autocrypt_db_close (struct AutocryptModuleData *mod_data)
	Close the Autocrypt SQLite database connection.
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.
struct AutocryptGossipHistory *	mutt_autocrypt_db_gossip_history_new (void)
	Create a new AutocryptGossipHistory.
int	mutt_autocrypt_db_init (bool can_create)
	Initialise the Autocrypt SQLite database.
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.
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.
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 AutocryptPeerHistory *	mutt_autocrypt_db_peer_history_new (void)
	Create a new AutocryptPeerHistory.
int	mutt_autocrypt_db_peer_insert (struct Address *addr, struct AutocryptPeer *peer)
	Insert a peer into the Autocrypt database.
struct AutocryptPeer *	mutt_autocrypt_db_peer_new (void)
	Create a new AutocryptPeer.
int	mutt_autocrypt_db_peer_update (struct AutocryptPeer *peer)
	Update the peer info in an Autocrypt database.
int	mutt_autocrypt_schema_init (void)
	Set up an Autocrypt database.
int	mutt_autocrypt_schema_update (void)
	Update the version number of the Autocrypt database schema.
int	mutt_autocrypt_gpgme_create_key (struct Address *addr, struct Buffer *keyid, struct Buffer *keydata)
	Create a GPGME key.
int	mutt_autocrypt_gpgme_import_key (const char *keydata, struct Buffer *keyid)
	Read a key from GPGME.
int	mutt_autocrypt_gpgme_init (void)
	Initialise GPGME.
bool	mutt_autocrypt_gpgme_is_valid_key (const char *keyid)
	Is a key id valid?
int	mutt_autocrypt_gpgme_select_key (struct Buffer *keyid, struct Buffer *keydata)
	Select a Autocrypt key.
int	mutt_autocrypt_gpgme_select_or_create_key (struct Address *addr, struct Buffer *keyid, struct Buffer *keydata)
	Ask the user to select or create an Autocrypt key.
bool	populate_menu (struct Menu *menu)
	Add the Autocrypt data to a Menu.

Detailed Description

Shared constants/structs that are private to Autocrypt.

Authors

• Kevin J. McCarthy
• Richard Russon

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 private.h.

Enumeration Type Documentation

ExpandoDataAutocrypt

enum ExpandoDataAutocrypt

Expando UIDs for Autocrypt.

See also

ED_AUTOCRYPT, ExpandoDomain

Enumerator
ED_AUT_ENABLED	AutocryptAccount.enabled.
ED_AUT_KEYID	AutocryptAccount.keyid.
ED_AUT_ADDRESS	AccountEntry.addr.
ED_AUT_NUMBER	AccountEntry.num.
ED_AUT_PREFER_ENCRYPT	AutocryptAccount.prefer_encrypt.

Definition at line 57 of file private.h.

{
  ED_AUT_ENABLED = 1,          
  ED_AUT_KEYID,                
  ED_AUT_ADDRESS,              
  ED_AUT_NUMBER,               
  ED_AUT_PREFER_ENCRYPT,       
};

Function Documentation

ARRAY_HEAD()

ARRAY_HEAD	(	AccountEntryArray	,
		struct AccountEntry *	)

mutt_autocrypt_account_init()

int mutt_autocrypt_account_init

(

bool

prompt

)

Create a new Autocrypt account.

Parameters

prompt

Prompt the user

Return values

0	Success
-1	Error

This is used the first time autocrypt is initialized, and in the account menu.

Definition at line 150 of file autocrypt.c.

{
  struct Address *addr = NULL;
  struct AutocryptAccount *account = NULL;
  bool done = false;
  int rc = -1;
  bool prefer_encrypt = false;
 
  if (prompt)
  {
    /* L10N: The first time NeoMutt is started with $autocrypt set, it will
       create $autocrypt_dir and then prompt to create an autocrypt account
       with this message.  */
    if (query_yesorno_ignore_macro(_("Create an initial autocrypt account?"), MUTT_YES) != MUTT_YES)
      return 0;
  }
 
  struct Buffer *keyid = buf_pool_get();
  struct Buffer *keydata = buf_pool_get();
 
  const struct Address *c_from = cs_subset_address(NeoMutt->sub, "from");
  if (c_from)
  {
    addr = mutt_addr_copy(c_from);
    const char *const c_real_name = cs_subset_string(NeoMutt->sub, "real_name");
    if (!addr->personal && c_real_name)
      addr->personal = buf_new(c_real_name);
  }
 
  struct AddressList al = TAILQ_HEAD_INITIALIZER(al);
  mutt_addrlist_append(&al, addr);
 
  do
  {
    /* L10N: Autocrypt is asking for the email address to use for the
       autocrypt account.  This will generate a key and add a record
       to the database for use in autocrypt operations.  */
    if (mutt_edit_address(&al, _("Autocrypt account address: "), false) != 0)
      goto cleanup;
 
    addr = TAILQ_FIRST(&al);
    if (!addr || !addr->mailbox || TAILQ_NEXT(addr, entries))
    {
      /* L10N: Autocrypt prompts for an account email address, and requires
         a single address.  This is shown if they entered something invalid,
         nothing, or more than one address for some reason.  */
      mutt_error(_("Please enter a single email address"));
      done = false;
    }
    else
    {
      done = true;
    }
  } while (!done);
 
  addr = TAILQ_FIRST(&al);
  if (mutt_autocrypt_db_account_get(addr, &account) < 0)
    goto cleanup;
  if (account)
  {
    /* L10N: When creating an autocrypt account, this message will be displayed
       if there is already an account in the database with the email address
       they just entered.  */
    mutt_error(_("That email address already has an autocrypt account"));
    goto cleanup;
  }
 
  if (mutt_autocrypt_gpgme_select_or_create_key(addr, keyid, keydata))
    goto cleanup;
 
  /* L10N: Autocrypt has a setting "prefer-encrypt".
     When the recommendation algorithm returns "available" and BOTH sender and
     recipient choose "prefer-encrypt", encryption will be automatically
     enabled.
     Otherwise the UI will show encryption is "available" but the user
     will be required to enable encryption manually.  */
  if (query_yesorno_ignore_macro(_("Prefer encryption?"), MUTT_NO) == MUTT_YES)
    prefer_encrypt = true;
 
  if (mutt_autocrypt_db_account_insert(addr, buf_string(keyid), buf_string(keydata), prefer_encrypt))
  {
    goto cleanup;
  }
 
  rc = 0;
 
cleanup:
  if (rc == 0)
  {
    /* L10N: Message displayed after an autocrypt account is successfully created.  */
    mutt_message(_("Autocrypt account creation succeeded"));
  }
  else
  {
    /* L10N: Error message displayed if creating an autocrypt account failed
       or was aborted by the user.  */
    mutt_error(_("Autocrypt account creation aborted"));
  }
 
  mutt_autocrypt_db_account_free(&account);
  mutt_addrlist_clear(&al);
  buf_pool_release(&keyid);
  buf_pool_release(&keydata);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_autocrypt_scan_mailboxes()

void mutt_autocrypt_scan_mailboxes

(

void

)

Scan mailboxes for Autocrypt headers.

This is invoked during the first autocrypt initialization, to scan one or more mailboxes for autocrypt headers.

Due to the implementation, header-cached headers are not scanned, so this routine just opens up the mailboxes with $header_cache temporarily disabled.

Definition at line 937 of file autocrypt.c.

{
#ifdef USE_HCACHE
  const char *c_header_cache = cs_subset_path(NeoMutt->sub, "header_cache");
  char *old_hdrcache = mutt_str_dup(c_header_cache);
  cs_subset_str_native_set(NeoMutt->sub, "header_cache", 0, NULL);
#endif
 
  struct Buffer *folderbuf = buf_pool_get();
 
  /* L10N: The first time autocrypt is enabled, NeoMutt will ask to scan
     through one or more mailboxes for Autocrypt: headers.  Those headers are
     then captured in the database as peer records and used for encryption.
     If this is answered yes, they will be prompted for a mailbox.  */
  enum QuadOption scan = query_yesorno_ignore_macro(_("Scan a mailbox for autocrypt headers?"),
                                                    MUTT_YES);
  while (scan == MUTT_YES)
  {
    struct Mailbox *m_cur = get_current_mailbox();
    // L10N: The prompt for a mailbox to scan for Autocrypt: headers
    if ((!mw_enter_fname(_("Scan mailbox"), folderbuf, true, m_cur, false, NULL,
                         NULL, MUTT_SEL_NO_FLAGS)) &&
        (!buf_is_empty(folderbuf)))
    {
      expand_path(folderbuf, false);
      struct Mailbox *m_ac = mx_path_resolve(buf_string(folderbuf));
      /* NOTE: I am purposely *not* executing folder hooks here,
       * as they can do all sorts of things like push into the getch() buffer.
       * Authentication should be in account-hooks. */
      if (mx_mbox_open(m_ac, MUTT_READONLY))
      {
        mx_mbox_close(m_ac);
      }
      buf_reset(folderbuf);
    }
 
    /* L10N: This is the second prompt to see if the user would like
       to scan more than one mailbox for Autocrypt headers.
       I'm purposely being extra verbose; asking first then prompting
       for a mailbox.  This is because this is a one-time operation
       and I don't want them to accidentally ctrl-g and abort it.  */
    scan = query_yesorno_ignore_macro(_("Scan another mailbox for autocrypt headers?"), MUTT_YES);
  }
 
#ifdef USE_HCACHE
  cs_subset_str_native_set(NeoMutt->sub, "header_cache", (intptr_t) old_hdrcache, NULL);
  old_hdrcache = NULL;
#endif
  buf_pool_release(&folderbuf);
}

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_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_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_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_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_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_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_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:

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_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_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:

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_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_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_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_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_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_schema_init()

int mutt_autocrypt_schema_init

(

void

)

Set up an Autocrypt database.

Return values

0	Success
-1	Error

Definition at line 43 of file schema.c.

{
  char *errmsg = NULL;
  struct AutocryptModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_AUTOCRYPT);
  sqlite3 *db = mod_data->autocrypt_db;
 
  const char *schema = "BEGIN TRANSACTION; "
 
                       "CREATE TABLE account ("
                       "email_addr text primary key not null, "
                       "keyid text, "
                       "keydata text, "
                       "prefer_encrypt int, "
                       "enabled int);"
 
                       "CREATE TABLE peer ("
                       "email_addr text primary key not null, "
                       "last_seen int, "
                       "autocrypt_timestamp int, "
                       "keyid text, "
                       "keydata text, "
                       "prefer_encrypt int, "
                       "gossip_timestamp int, "
                       "gossip_keyid text, "
                       "gossip_keydata text);"
 
                       "CREATE TABLE peer_history ("
                       "peer_email_addr text not null, "
                       "email_msgid text, "
                       "timestamp int, "
                       "keydata text);"
 
                       "CREATE INDEX peer_history_email "
                       "ON peer_history ("
                       "peer_email_addr);"
 
                       "CREATE TABLE gossip_history ("
                       "peer_email_addr text not null, "
                       "sender_email_addr text, "
                       "email_msgid text, "
                       "timestamp int, "
                       "gossip_keydata text);"
 
                       "CREATE INDEX gossip_history_email "
                       "ON gossip_history ("
                       "peer_email_addr);"
 
                       "CREATE TABLE schema ("
                       "version int);"
 
                       "INSERT into schema (version) values (1);"
 
                       "COMMIT TRANSACTION";
 
  if (sqlite3_exec(db, schema, NULL, NULL, &errmsg) != SQLITE_OK)
  {
    mutt_debug(LL_DEBUG1, "mutt_autocrypt_schema_init() returned %s\n", errmsg);
    sqlite3_free(errmsg);
    return -1;
  }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_autocrypt_schema_update()

int mutt_autocrypt_schema_update

(

void

)

Update the version number of the Autocrypt database schema.

Return values

0	Success
-1	Error

Definition at line 111 of file schema.c.

{
  sqlite3_stmt *stmt = NULL;
  int rc = -1;
  struct AutocryptModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_AUTOCRYPT);
  sqlite3 *db = mod_data->autocrypt_db;
 
  if (sqlite3_prepare_v2(db, "SELECT version FROM schema;", -1, &stmt, NULL) != SQLITE_OK)
    goto cleanup;
 
  if (sqlite3_step(stmt) != SQLITE_ROW)
    goto cleanup;
 
  int version = sqlite3_column_int(stmt, 0);
 
  if (version > 1)
  {
    /* L10N: The autocrypt database keeps track of schema version numbers.
       This error occurs if the version number is too high.
       Presumably because this is an old version of NeoMutt and the
       database was upgraded by a future version.  */
    mutt_error(_("Autocrypt database version is too new"));
    goto cleanup;
  }
 
  /* TODO: schema version upgrades go here.
   * Bump one by one, each update inside a transaction. */
 
  rc = 0;
 
cleanup:
  sqlite3_finalize(stmt);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_autocrypt_gpgme_create_key()

int mutt_autocrypt_gpgme_create_key	(	struct Address *	addr,
		struct Buffer *	keyid,
		struct Buffer *	keydata )

Create a GPGME key.

Parameters

addr	Email Address
keyid	Key id
keydata	Key data

Return values

0	Success
-1	Error

Definition at line 158 of file gpgme.c.

{
  int rc = -1;
  gpgme_ctx_t ctx = NULL;
  gpgme_genkey_result_t keyresult = NULL;
  gpgme_key_t primary_key = NULL;
  struct Buffer *buf = buf_pool_get();
 
  /* GPGME says addresses should not be in idna form */
  struct Address *copy = mutt_addr_copy(addr);
  mutt_addr_to_local(copy);
  mutt_addr_write(buf, copy, false);
  mutt_addr_free(&copy);
 
  if (create_gpgme_context(&ctx))
    goto cleanup;
 
  /* L10N: Message displayed just before a GPG key is generated for a created
     autocrypt account.  */
  mutt_message(_("Generating autocrypt key..."));
 
  /* Primary key */
  gpgme_error_t err = gpgme_op_createkey(ctx, buf_string(buf), "ed25519", 0, 0, NULL,
                                         GPGME_CREATE_NOPASSWD | GPGME_CREATE_FORCE |
                                             GPGME_CREATE_NOEXPIRE);
  if (err != GPG_ERR_NO_ERROR)
  {
    /* L10N: GPGME was unable to generate a key for some reason.
       %s is the error message returned by GPGME.  */
    mutt_error(_("Error creating autocrypt key: %s"), gpgme_strerror(err));
    goto cleanup;
  }
  keyresult = gpgme_op_genkey_result(ctx);
  if (!keyresult->fpr)
    goto cleanup;
  buf_strcpy(keyid, keyresult->fpr);
  mutt_debug(LL_DEBUG1, "Generated key with id %s\n", buf_string(keyid));
 
  /* Get gpgme_key_t to create the secondary key and export keydata */
  err = gpgme_get_key(ctx, buf_string(keyid), &primary_key, 0);
  if (err)
    goto cleanup;
 
  /* Secondary key */
  err = gpgme_op_createsubkey(ctx, primary_key, "cv25519", 0, 0,
                              GPGME_CREATE_NOPASSWD | GPGME_CREATE_NOEXPIRE);
  if (err != GPG_ERR_NO_ERROR)
  {
    mutt_error(_("Error creating autocrypt key: %s"), gpgme_strerror(err));
    goto cleanup;
  }
 
  /* get keydata */
  if (export_keydata(ctx, primary_key, keydata))
    goto cleanup;
  mutt_debug(LL_DEBUG1, "key has keydata *%s*\n", buf_string(keydata));
 
  rc = 0;
 
cleanup:
  gpgme_key_unref(primary_key);
  gpgme_release(ctx);
  buf_pool_release(&buf);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_autocrypt_gpgme_import_key()

int mutt_autocrypt_gpgme_import_key	(	const char *	keydata,
		struct Buffer *	keyid )

Read a key from GPGME.

Parameters

keydata	Buffer for key data
keyid	Buffer for key id

Return values

0	Success
-1	Error

Definition at line 320 of file gpgme.c.

{
  int rc = -1;
  gpgme_ctx_t ctx = NULL;
  gpgme_data_t dh = NULL;
  struct Buffer *raw_keydata = NULL;
 
  if (create_gpgme_context(&ctx))
    goto cleanup;
 
  raw_keydata = buf_pool_get();
  if (!mutt_b64_buffer_decode(raw_keydata, keydata))
    goto cleanup;
 
  if (gpgme_data_new_from_mem(&dh, buf_string(raw_keydata), buf_len(raw_keydata), 0))
  {
    goto cleanup;
  }
 
  if (gpgme_op_import(ctx, dh))
    goto cleanup;
 
  gpgme_import_result_t result = gpgme_op_import_result(ctx);
  if (!result->imports || !result->imports->fpr)
    goto cleanup;
  buf_strcpy(keyid, result->imports->fpr);
 
  rc = 0;
 
cleanup:
  gpgme_data_release(dh);
  gpgme_release(ctx);
  buf_pool_release(&raw_keydata);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_autocrypt_gpgme_init()

int mutt_autocrypt_gpgme_init

(

void

)

Initialise GPGME.

Return values

0

Always

Definition at line 70 of file gpgme.c.

{
  pgp_gpgme_init();
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_autocrypt_gpgme_is_valid_key()

bool mutt_autocrypt_gpgme_is_valid_key

(

const char *

keyid

)

Is a key id valid?

Parameters

keyid

Key id to check

Return values

true	Key id is valid

Definition at line 361 of file gpgme.c.

{
  bool rc = false;
  gpgme_ctx_t ctx = NULL;
  gpgme_key_t key = NULL;
 
  if (!keyid)
    return false;
 
  if (create_gpgme_context(&ctx))
    goto cleanup;
 
  if (gpgme_get_key(ctx, keyid, &key, 0))
    goto cleanup;
 
  rc = true;
  if (key->revoked || key->expired || key->disabled || key->invalid || !key->can_encrypt)
    rc = false;
 
cleanup:
  gpgme_key_unref(key);
  gpgme_release(ctx);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_autocrypt_gpgme_select_key()

int mutt_autocrypt_gpgme_select_key	(	struct Buffer *	keyid,
		struct Buffer *	keydata )

Select a Autocrypt key.

Parameters

[in]	keyid	Key id to select
[out]	keydata	Buffer for resulting Key data

Return values

0	Success
-1	Error

Definition at line 232 of file gpgme.c.

{
  int rc = -1;
  gpgme_ctx_t ctx = NULL;
  gpgme_key_t key = NULL;
 
  OptAutocryptGpgme = true;
  if (mutt_gpgme_select_secret_key(keyid))
    goto cleanup;
 
  if (create_gpgme_context(&ctx))
    goto cleanup;
 
  if (gpgme_get_key(ctx, buf_string(keyid), &key, 0))
    goto cleanup;
 
  if (key->revoked || key->expired || key->disabled || key->invalid ||
      !key->can_encrypt || !key->can_sign)
  {
    /* L10N: After selecting a key for an autocrypt account,
       this is displayed if the key was revoked/expired/disabled/invalid
       or can't be used for both signing and encryption.
       %s is the key fingerprint.  */
    mutt_error(_("The key %s is not usable for autocrypt"), buf_string(keyid));
    goto cleanup;
  }
 
  if (export_keydata(ctx, key, keydata))
    goto cleanup;
 
  rc = 0;
 
cleanup:
  OptAutocryptGpgme = false;
  gpgme_key_unref(key);
  gpgme_release(ctx);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_autocrypt_gpgme_select_or_create_key()

int mutt_autocrypt_gpgme_select_or_create_key	(	struct Address *	addr,
		struct Buffer *	keyid,
		struct Buffer *	keydata )

Ask the user to select or create an Autocrypt key.

Parameters

addr	Email Address
keyid	Key id
keydata	Key data

Return values

0	Success
-1	Error

Definition at line 279 of file gpgme.c.

{
  int rc = -1;
 
  /* L10N: During autocrypt account creation, this prompt asks the
     user whether they want to create a new GPG key for the account,
     or select an existing account from the keyring.  */
  const char *prompt = _("(c)reate new, or (s)elect existing GPG key?");
  /* L10N: The letters corresponding to the
     "(c)reate new, or (s)elect existing GPG key?" prompt.  */
  const char *letters = _("cs");
 
  int choice = mw_multi_choice(prompt, letters);
  switch (choice)
  {
    case 2: /* select existing */
      rc = mutt_autocrypt_gpgme_select_key(keyid, keydata);
      if (rc == 0)
        break;
 
      /* L10N: During autocrypt account creation, if selecting an existing key fails
         for some reason, we prompt to see if they want to create a key instead.  */
      if (query_yesorno(_("Create a new GPG key for this account, instead?"), MUTT_YES) != MUTT_YES)
        break;
      FALLTHROUGH;
 
    case 1: /* create new */
      rc = mutt_autocrypt_gpgme_create_key(addr, keyid, keydata);
  }
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

populate_menu()

bool populate_menu

(

struct Menu *

menu

)

Add the Autocrypt data to a Menu.

Parameters

menu	Menu to populate

Return values

true

Success

Definition at line 145 of file dlg_autocrypt.c.

{
  struct AutocryptData *ad = menu->mdata;
 
  // Clear out any existing data
  account_entry_array_clear(&ad->entries);
  menu->max = 0;
 
  struct AutocryptAccountArray accounts = ARRAY_HEAD_INITIALIZER;
 
  if (mutt_autocrypt_db_account_get_all(&accounts) < 0)
    return false;
 
  menu->max = ARRAY_SIZE(&accounts);
 
  struct AutocryptAccount **pac = NULL;
  ARRAY_FOREACH(pac, &accounts)
  {
    struct AccountEntry *entry = MUTT_MEM_CALLOC(1, struct AccountEntry);
 
    entry->num = ARRAY_FOREACH_IDX_pac + 1;
    /* note: we are transferring the account pointer to the entries
     * array, and freeing the accounts array below.  the account
     * will be freed in autocrypt_menu_free().  */
    entry->account = *pac;
 
    entry->addr = mutt_addr_new();
    entry->addr->mailbox = buf_new((*pac)->email_addr);
    mutt_addr_to_local(entry->addr);
    ARRAY_ADD(&ad->entries, entry);
  }
  ARRAY_FREE(&accounts);
 
  menu_queue_redraw(menu, MENU_REDRAW_FULL);
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function: