lib.h File Reference

Autocrypt end-to-end encryption. More...

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

Include dependency graph for lib.h:

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

Go to the source code of this file.

Data Structures
struct	AutocryptAccount
	Autocrypt account. More...
struct	AutocryptPeer
	Autocrypt peer. More...
struct	AutocryptPeerHistory
	Autocrypt peer history. More...
struct	AutocryptGossipHistory
	Autocrypt gossip history. More...

Enumerations
enum	AutocryptRec {   AUTOCRYPT_REC_OFF , AUTOCRYPT_REC_NO , AUTOCRYPT_REC_DISCOURAGE , AUTOCRYPT_REC_AVAILABLE ,   AUTOCRYPT_REC_YES }
	Recommendation. More...

Functions
	ARRAY_HEAD (AutocryptAccountArray, struct AutocryptAccount *)
void	autocrypt_init_keys (struct NeoMutt *n, struct SubMenu *sm_generic)
	Initialise the Autocrypt Keybindings - Implements ::init_keys_api.
void	dlg_autocrypt (void)
	Display the Autocrypt account Menu -.
void	mutt_autocrypt_cleanup (void)
	Shutdown Autocrypt.
int	mutt_autocrypt_generate_gossip_list (struct Email *e)
	Create the gossip list headers.
int	mutt_autocrypt_init (bool can_create)
	Initialise Autocrypt.
int	mutt_autocrypt_process_autocrypt_header (struct Email *e, struct Envelope *env)
	Parse an Autocrypt email header.
int	mutt_autocrypt_process_gossip_header (struct Email *e, struct Envelope *prot_headers)
	Parse an Autocrypt email gossip header.
int	mutt_autocrypt_set_sign_as_default_key (struct Email *e)
	Set the Autocrypt default key for signing.
enum AutocryptRec	mutt_autocrypt_ui_recommendation (const struct Email *e, char **keylist)
	Get the recommended action for an Email.
int	mutt_autocrypt_write_autocrypt_header (struct Envelope *env, FILE *fp)
	Write the Autocrypt header to a file.
int	mutt_autocrypt_write_gossip_headers (struct Envelope *env, FILE *fp)
	Write the Autocrypt gossip headers to a file.

Detailed Description

Autocrypt end-to-end encryption.

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

Enumeration Type Documentation

AutocryptRec

enum AutocryptRec

Recommendation.

Enumerator
AUTOCRYPT_REC_OFF	No recommendations.
AUTOCRYPT_REC_NO	Do no use Autocrypt.
AUTOCRYPT_REC_DISCOURAGE	Prefer not to use Autocrypt.
AUTOCRYPT_REC_AVAILABLE	Autocrypt is available.
AUTOCRYPT_REC_YES	Autocrypt should be used.

Definition at line 165 of file lib.h.

{
  AUTOCRYPT_REC_OFF,        
  AUTOCRYPT_REC_NO,         
  AUTOCRYPT_REC_DISCOURAGE, 
  AUTOCRYPT_REC_AVAILABLE,  
  AUTOCRYPT_REC_YES,        
};

Function Documentation

ARRAY_HEAD()

ARRAY_HEAD	(	AutocryptAccountArray	,
		struct AutocryptAccount *	)

autocrypt_init_keys()

void autocrypt_init_keys	(	struct NeoMutt *	n,
		struct SubMenu *	sm_generic )

Initialise the Autocrypt Keybindings - Implements ::init_keys_api.

Definition at line 75 of file functions.c.

{
  struct AutocryptModuleData *mod_data = neomutt_get_module_data(n, MODULE_ID_AUTOCRYPT);
  ASSERT(mod_data);
 
  struct MenuDefinition *md = NULL;
  struct SubMenu *sm = NULL;
 
  sm = km_register_submenu(OpAutocrypt);
  md = km_register_menu(MENU_AUTOCRYPT, "autocrypt");
  km_menu_add_submenu(md, sm);
  km_menu_add_submenu(md, sm_generic);
  km_menu_add_bindings(md, AutocryptDefaultBindings);
 
  mod_data->menu_autocrypt = md;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_autocrypt_cleanup()

void mutt_autocrypt_cleanup

(

void

)

Shutdown Autocrypt.

Definition at line 135 of file autocrypt.c.

{
  mutt_autocrypt_db_close();
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_autocrypt_generate_gossip_list()

int mutt_autocrypt_generate_gossip_list

(

struct Email *

e

)

Create the gossip list headers.

Parameters

e

Email

Return values

0	Success
-1	Error

Definition at line 843 of file autocrypt.c.

{
  int rc = -1;
  struct AutocryptPeer *peer = NULL;
  struct AutocryptAccount *account = NULL;
  struct Address *recip = NULL;
 
  const bool c_autocrypt = cs_subset_bool(NeoMutt->sub, "autocrypt");
  if (!c_autocrypt || mutt_autocrypt_init(false) || !e)
    return -1;
 
  struct Envelope *mime_headers = e->body->mime_headers;
  if (!mime_headers)
    mime_headers = e->body->mime_headers = mutt_env_new();
  mutt_autocrypthdr_free(&mime_headers->autocrypt_gossip);
 
  struct AddressList recips = TAILQ_HEAD_INITIALIZER(recips);
 
  mutt_addrlist_copy(&recips, &e->env->to, false);
  mutt_addrlist_copy(&recips, &e->env->cc, false);
 
  TAILQ_FOREACH(recip, &recips, entries)
  {
    /* At this point, we just accept missing keys and include what we can. */
    if (mutt_autocrypt_db_peer_get(recip, &peer) <= 0)
      continue;
 
    const char *keydata = NULL;
    if (mutt_autocrypt_gpgme_is_valid_key(peer->keyid))
      keydata = peer->keydata;
    else if (mutt_autocrypt_gpgme_is_valid_key(peer->gossip_keyid))
      keydata = peer->gossip_keydata;
 
    if (keydata)
    {
      struct AutocryptHeader *gossip = mutt_autocrypthdr_new();
      gossip->addr = mutt_str_dup(peer->email_addr);
      gossip->keydata = mutt_str_dup(keydata);
      gossip->next = mime_headers->autocrypt_gossip;
      mime_headers->autocrypt_gossip = gossip;
    }
 
    mutt_autocrypt_db_peer_free(&peer);
  }
 
  TAILQ_FOREACH(recip, &e->env->reply_to, entries)
  {
    const char *addr = NULL;
    const char *keydata = NULL;
    if (mutt_autocrypt_db_account_get(recip, &account) > 0)
    {
      addr = account->email_addr;
      keydata = account->keydata;
    }
    else if (mutt_autocrypt_db_peer_get(recip, &peer) > 0)
    {
      addr = peer->email_addr;
      if (mutt_autocrypt_gpgme_is_valid_key(peer->keyid))
        keydata = peer->keydata;
      else if (mutt_autocrypt_gpgme_is_valid_key(peer->gossip_keyid))
        keydata = peer->gossip_keydata;
    }
 
    if (keydata)
    {
      struct AutocryptHeader *gossip = mutt_autocrypthdr_new();
      gossip->addr = mutt_str_dup(addr);
      gossip->keydata = mutt_str_dup(keydata);
      gossip->next = mime_headers->autocrypt_gossip;
      mime_headers->autocrypt_gossip = gossip;
    }
    mutt_autocrypt_db_account_free(&account);
    mutt_autocrypt_db_peer_free(&peer);
  }
 
  rc = 0;
 
  mutt_addrlist_clear(&recips);
  mutt_autocrypt_db_account_free(&account);
  mutt_autocrypt_db_peer_free(&peer);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_autocrypt_init()

int mutt_autocrypt_init

(

bool

can_create

)

Initialise Autocrypt.

Parameters

can_create

If true, directories may be created

Return values

0	Success
-1	Error

Definition at line 104 of file autocrypt.c.

{
  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;
 
  if (autocrypt_dir_init(can_create))
    goto bail;
 
  if (mutt_autocrypt_gpgme_init())
    goto bail;
 
  if (mutt_autocrypt_db_init(can_create))
    goto bail;
 
  return 0;
 
bail:
  cs_subset_str_native_set(NeoMutt->sub, "autocrypt", false, NULL);
  mutt_autocrypt_db_close();
  return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_autocrypt_process_autocrypt_header()

int mutt_autocrypt_process_autocrypt_header	(	struct Email *	e,
		struct Envelope *	env )

Parse an Autocrypt email header.

Parameters

e	Email
env	Envelope

Return values

0	Success
-1	Error

Definition at line 262 of file autocrypt.c.

{
  struct AutocryptHeader *valid_ac_hdr = NULL;
  struct AutocryptPeer *peer = NULL;
  struct AutocryptPeerHistory *peerhist = NULL;
  struct Buffer *keyid = NULL;
  bool update_db = false, insert_db = false, insert_db_history = false, import_gpg = false;
  int rc = -1;
 
  const bool c_autocrypt = cs_subset_bool(NeoMutt->sub, "autocrypt");
  if (!c_autocrypt)
    return 0;
 
  if (mutt_autocrypt_init(false))
    return -1;
 
  if (!e || !e->body || !env)
    return 0;
 
  /* 1.1 spec says to skip emails with more than one From header */
  struct Address *from = TAILQ_FIRST(&env->from);
  if (!from || TAILQ_NEXT(from, entries))
    return 0;
 
  /* 1.1 spec also says to skip multipart/report emails */
  if ((e->body->type == TYPE_MULTIPART) && mutt_istr_equal(e->body->subtype, "report"))
  {
    return 0;
  }
 
  /* Ignore emails that appear to be more than a week in the future,
   * since they can block all future updates during that time. */
  if (e->date_sent > (mutt_date_now() + (7 * 24 * 60 * 60)))
    return 0;
 
  for (struct AutocryptHeader *ac_hdr = env->autocrypt; ac_hdr; ac_hdr = ac_hdr->next)
  {
    if (ac_hdr->invalid)
      continue;
 
    /* NOTE: this assumes the processing is occurring right after
     * mutt_parse_rfc822_line() and the from ADDR is still in the same
     * form (intl) as the autocrypt header addr field */
    if (!mutt_istr_equal(buf_string(from->mailbox), ac_hdr->addr))
      continue;
 
    /* 1.1 spec says ignore all, if more than one valid header is found. */
    if (valid_ac_hdr)
    {
      valid_ac_hdr = NULL;
      break;
    }
    valid_ac_hdr = ac_hdr;
  }
 
  if (mutt_autocrypt_db_peer_get(from, &peer) < 0)
    goto cleanup;
 
  if (peer)
  {
    if (e->date_sent <= peer->autocrypt_timestamp)
    {
      rc = 0;
      goto cleanup;
    }
 
    if (e->date_sent > peer->last_seen)
    {
      update_db = true;
      peer->last_seen = e->date_sent;
    }
 
    if (valid_ac_hdr)
    {
      update_db = true;
      peer->autocrypt_timestamp = e->date_sent;
      peer->prefer_encrypt = valid_ac_hdr->prefer_encrypt;
      if (!mutt_str_equal(peer->keydata, valid_ac_hdr->keydata))
      {
        import_gpg = true;
        insert_db_history = true;
        mutt_str_replace(&peer->keydata, valid_ac_hdr->keydata);
      }
    }
  }
  else if (valid_ac_hdr)
  {
    import_gpg = true;
    insert_db = true;
    insert_db_history = true;
  }
 
  if (!(import_gpg || insert_db || update_db))
  {
    rc = 0;
    goto cleanup;
  }
 
  if (!peer)
  {
    peer = mutt_autocrypt_db_peer_new();
    peer->last_seen = e->date_sent;
    peer->autocrypt_timestamp = e->date_sent;
    peer->keydata = mutt_str_dup(valid_ac_hdr->keydata);
    peer->prefer_encrypt = valid_ac_hdr->prefer_encrypt;
  }
 
  if (import_gpg)
  {
    keyid = buf_pool_get();
    if (mutt_autocrypt_gpgme_import_key(peer->keydata, keyid))
      goto cleanup;
    mutt_str_replace(&peer->keyid, buf_string(keyid));
  }
 
  if (insert_db && mutt_autocrypt_db_peer_insert(from, peer))
    goto cleanup;
 
  if (update_db && mutt_autocrypt_db_peer_update(peer))
    goto cleanup;
 
  if (insert_db_history)
  {
    peerhist = mutt_autocrypt_db_peer_history_new();
    peerhist->email_msgid = mutt_str_dup(env->message_id);
    peerhist->timestamp = e->date_sent;
    peerhist->keydata = mutt_str_dup(peer->keydata);
    if (mutt_autocrypt_db_peer_history_insert(from, peerhist))
      goto cleanup;
  }
 
  rc = 0;
 
cleanup:
  mutt_autocrypt_db_peer_free(&peer);
  mutt_autocrypt_db_peer_history_free(&peerhist);
  buf_pool_release(&keyid);
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_autocrypt_process_gossip_header()

int mutt_autocrypt_process_gossip_header	(	struct Email *	e,
		struct Envelope *	prot_headers )

Parse an Autocrypt email gossip header.

Parameters

e	Email
prot_headers	Envelope with protected headers

Return values

0	Success
-1	Error

Definition at line 410 of file autocrypt.c.

{
  struct AutocryptPeer *peer = NULL;
  struct AutocryptGossipHistory *gossip_hist = NULL;
  struct Buffer *keyid = NULL;
  struct Address *peer_addr = NULL;
  struct Address ac_hdr_addr = { 0 };
  ac_hdr_addr.mailbox = buf_new(NULL);
  struct AddressList recips = TAILQ_HEAD_INITIALIZER(recips);
  bool update_db = false, insert_db = false, insert_db_history = false, import_gpg = false;
  int rc = -1;
 
  const bool c_autocrypt = cs_subset_bool(NeoMutt->sub, "autocrypt");
  if (!c_autocrypt)
  {
    rc = 0;
    goto cleanup;
  }
 
  if (mutt_autocrypt_init(false))
    goto cleanup;
 
  if (!e || !e->env || !prot_headers)
  {
    rc = 0;
    goto cleanup;
  }
 
  struct Envelope *env = e->env;
 
  struct Address *from = TAILQ_FIRST(&env->from);
  if (!from)
  {
    rc = 0;
    goto cleanup;
  }
 
  /* Ignore emails that appear to be more than a week in the future,
   * since they can block all future updates during that time. */
  if (e->date_sent > (mutt_date_now() + (7 * 24 * 60 * 60)))
  {
    rc = 0;
    goto cleanup;
  }
 
  keyid = buf_pool_get();
 
  /* Normalize the recipient list for comparison */
  mutt_addrlist_copy(&recips, &env->to, false);
  mutt_addrlist_copy(&recips, &env->cc, false);
  mutt_addrlist_copy(&recips, &env->reply_to, false);
  mutt_autocrypt_db_normalize_addrlist(&recips);
 
  for (struct AutocryptHeader *ac_hdr = prot_headers->autocrypt_gossip; ac_hdr;
       ac_hdr = ac_hdr->next)
  {
    if (ac_hdr->invalid)
      continue;
 
    /* normalize for comparison against recipient list */
    buf_strcpy(ac_hdr_addr.mailbox, ac_hdr->addr);
    ac_hdr_addr.is_intl = true;
    ac_hdr_addr.intl_checked = true;
    mutt_autocrypt_db_normalize_addr(&ac_hdr_addr);
 
    /* Check to make sure the address is in the recipient list. */
    TAILQ_FOREACH(peer_addr, &recips, entries)
    {
      if (buf_str_equal(peer_addr->mailbox, ac_hdr_addr.mailbox))
        break;
    }
 
    if (!peer_addr)
      continue;
 
    if (mutt_autocrypt_db_peer_get(peer_addr, &peer) < 0)
      goto cleanup;
 
    if (peer)
    {
      if (e->date_sent <= peer->gossip_timestamp)
      {
        mutt_autocrypt_db_peer_free(&peer);
        continue;
      }
 
      update_db = true;
      peer->gossip_timestamp = e->date_sent;
      /* This is slightly different from the autocrypt 1.1 spec.
       * Avoid setting an empty peer.gossip_keydata with a value that matches
       * the current peer.keydata. */
      if ((peer->gossip_keydata && !mutt_str_equal(peer->gossip_keydata, ac_hdr->keydata)) ||
          (!peer->gossip_keydata && !mutt_str_equal(peer->keydata, ac_hdr->keydata)))
      {
        import_gpg = true;
        insert_db_history = true;
        mutt_str_replace(&peer->gossip_keydata, ac_hdr->keydata);
      }
    }
    else
    {
      import_gpg = true;
      insert_db = true;
      insert_db_history = true;
    }
 
    if (!peer)
    {
      peer = mutt_autocrypt_db_peer_new();
      peer->gossip_timestamp = e->date_sent;
      peer->gossip_keydata = mutt_str_dup(ac_hdr->keydata);
    }
 
    if (import_gpg)
    {
      if (mutt_autocrypt_gpgme_import_key(peer->gossip_keydata, keyid))
        goto cleanup;
      mutt_str_replace(&peer->gossip_keyid, buf_string(keyid));
    }
 
    if (insert_db && mutt_autocrypt_db_peer_insert(peer_addr, peer))
      goto cleanup;
 
    if (update_db && mutt_autocrypt_db_peer_update(peer))
      goto cleanup;
 
    if (insert_db_history)
    {
      gossip_hist = mutt_autocrypt_db_gossip_history_new();
      gossip_hist->sender_email_addr = buf_strdup(from->mailbox);
      gossip_hist->email_msgid = mutt_str_dup(env->message_id);
      gossip_hist->timestamp = e->date_sent;
      gossip_hist->gossip_keydata = mutt_str_dup(peer->gossip_keydata);
      if (mutt_autocrypt_db_gossip_history_insert(peer_addr, gossip_hist))
        goto cleanup;
    }
 
    mutt_autocrypt_db_peer_free(&peer);
    mutt_autocrypt_db_gossip_history_free(&gossip_hist);
    buf_reset(keyid);
    update_db = false;
    insert_db = false;
    insert_db_history = false;
    import_gpg = false;
  }
 
  rc = 0;
 
cleanup:
  buf_free(&ac_hdr_addr.mailbox);
  mutt_addrlist_clear(&recips);
  mutt_autocrypt_db_peer_free(&peer);
  mutt_autocrypt_db_gossip_history_free(&gossip_hist);
  buf_pool_release(&keyid);
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_autocrypt_set_sign_as_default_key()

int mutt_autocrypt_set_sign_as_default_key

(

struct Email *

e

)

Set the Autocrypt default key for signing.

Parameters

e

Email

Return values

0	Success
-1	Error

Definition at line 716 of file autocrypt.c.

{
  int rc = -1;
  struct AutocryptAccount *account = NULL;
  struct AutocryptModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_AUTOCRYPT);
 
  const bool c_autocrypt = cs_subset_bool(NeoMutt->sub, "autocrypt");
  if (!c_autocrypt || mutt_autocrypt_init(false) || !e)
    return -1;
 
  struct Address *from = TAILQ_FIRST(&e->env->from);
  if (!from || TAILQ_NEXT(from, entries))
    return -1;
 
  if (mutt_autocrypt_db_account_get(from, &account) <= 0)
    goto cleanup;
  if (!account->keyid)
    goto cleanup;
  if (!account->enabled)
    goto cleanup;
 
  mutt_str_replace(&mod_data->autocrypt_sign_as, account->keyid);
  mutt_str_replace(&mod_data->autocrypt_default_key, account->keyid);
 
  rc = 0;
 
cleanup:
  mutt_autocrypt_db_account_free(&account);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_autocrypt_ui_recommendation()

enum AutocryptRec mutt_autocrypt_ui_recommendation	(	const struct Email *	e,
		char **	keylist )

Get the recommended action for an Email.

Parameters

[in]	e	Email
[out]	keylist	List of Autocrypt key ids

Return values

enum	AutocryptRec Recommendation, e.g. AUTOCRYPT_REC_AVAILABLE

If the recommendataion is > NO and keylist is not NULL, keylist will be populated with the autocrypt keyids.

Definition at line 577 of file autocrypt.c.

{
  enum AutocryptRec rc = AUTOCRYPT_REC_OFF;
  struct AutocryptAccount *account = NULL;
  struct AutocryptPeer *peer = NULL;
  struct Address *recip = NULL;
  bool all_encrypt = true, has_discourage = false;
  const char *matching_key = NULL;
  struct AddressList recips = TAILQ_HEAD_INITIALIZER(recips);
  struct Buffer *keylist_buf = NULL;
 
  const bool c_autocrypt = cs_subset_bool(NeoMutt->sub, "autocrypt");
  if (!c_autocrypt || mutt_autocrypt_init(false) || !e)
  {
    if (keylist)
    {
      /* L10N: Error displayed if the user tries to force sending an Autocrypt
         email when the engine is not available.  */
      mutt_message(_("Autocrypt is not available"));
    }
    return AUTOCRYPT_REC_OFF;
  }
 
  struct Address *from = TAILQ_FIRST(&e->env->from);
  if (!from || TAILQ_NEXT(from, entries))
  {
    if (keylist)
      mutt_message(_("Autocrypt is not available"));
    return AUTOCRYPT_REC_OFF;
  }
 
  if (e->security & APPLICATION_SMIME)
  {
    if (keylist)
      mutt_message(_("Autocrypt is not available"));
    return AUTOCRYPT_REC_OFF;
  }
 
  if ((mutt_autocrypt_db_account_get(from, &account) <= 0) || !account->enabled)
  {
    if (keylist)
    {
      /* L10N: Error displayed if the user tries to force sending an Autocrypt
         email when the account does not exist or is not enabled.
         %s is the From email address used to look up the Autocrypt account.
      */
      mutt_message(_("Autocrypt is not enabled for %s"), buf_string(from->mailbox));
    }
    goto cleanup;
  }
 
  keylist_buf = buf_pool_get();
  buf_addstr(keylist_buf, account->keyid);
 
  mutt_addrlist_copy(&recips, &e->env->to, false);
  mutt_addrlist_copy(&recips, &e->env->cc, false);
  mutt_addrlist_copy(&recips, &e->env->bcc, false);
 
  rc = AUTOCRYPT_REC_NO;
  if (TAILQ_EMPTY(&recips))
    goto cleanup;
 
  TAILQ_FOREACH(recip, &recips, entries)
  {
    if (mutt_autocrypt_db_peer_get(recip, &peer) <= 0)
    {
      if (keylist)
      {
        /* L10N: s is an email address.  Autocrypt is scanning for the keyids
           to use to encrypt, but it can't find a valid keyid for this address.
           The message is printed and they are returned to the compose menu.  */
        mutt_message(_("No (valid) autocrypt key found for %s"),
                     buf_string(recip->mailbox));
      }
      goto cleanup;
    }
 
    if (mutt_autocrypt_gpgme_is_valid_key(peer->keyid))
    {
      matching_key = peer->keyid;
 
      if (!(peer->last_seen && peer->autocrypt_timestamp) ||
          (peer->last_seen - peer->autocrypt_timestamp > (35 * 24 * 60 * 60)))
      {
        has_discourage = true;
        all_encrypt = false;
      }
 
      if (!account->prefer_encrypt || !peer->prefer_encrypt)
        all_encrypt = false;
    }
    else if (mutt_autocrypt_gpgme_is_valid_key(peer->gossip_keyid))
    {
      matching_key = peer->gossip_keyid;
 
      has_discourage = true;
      all_encrypt = false;
    }
    else
    {
      if (keylist)
      {
        mutt_message(_("No (valid) autocrypt key found for %s"),
                     buf_string(recip->mailbox));
      }
      goto cleanup;
    }
 
    if (!buf_is_empty(keylist_buf))
      buf_addch(keylist_buf, ' ');
    buf_addstr(keylist_buf, matching_key);
 
    mutt_autocrypt_db_peer_free(&peer);
  }
 
  if (all_encrypt)
    rc = AUTOCRYPT_REC_YES;
  else if (has_discourage)
    rc = AUTOCRYPT_REC_DISCOURAGE;
  else
    rc = AUTOCRYPT_REC_AVAILABLE;
 
  if (keylist)
    mutt_str_replace(keylist, buf_string(keylist_buf));
 
cleanup:
  mutt_autocrypt_db_account_free(&account);
  mutt_addrlist_clear(&recips);
  mutt_autocrypt_db_peer_free(&peer);
  buf_pool_release(&keylist_buf);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_autocrypt_write_autocrypt_header()

int mutt_autocrypt_write_autocrypt_header	(	struct Envelope *	env,
		FILE *	fp )

Write the Autocrypt header to a file.

Parameters

env	Envelope
fp	File to write to

Return values

0	Success
-1	Error

Definition at line 783 of file autocrypt.c.

{
  int rc = -1;
  struct AutocryptAccount *account = NULL;
 
  const bool c_autocrypt = cs_subset_bool(NeoMutt->sub, "autocrypt");
  if (!c_autocrypt || mutt_autocrypt_init(false) || !env)
    return -1;
 
  struct Address *from = TAILQ_FIRST(&env->from);
  if (!from || TAILQ_NEXT(from, entries))
    return -1;
 
  if (mutt_autocrypt_db_account_get(from, &account) <= 0)
    goto cleanup;
  if (!account->keydata)
    goto cleanup;
  if (!account->enabled)
    goto cleanup;
 
  fputs("Autocrypt: ", fp);
  write_autocrypt_header_line(fp, account->email_addr, account->prefer_encrypt,
                              account->keydata);
 
  rc = 0;
 
cleanup:
  mutt_autocrypt_db_account_free(&account);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_autocrypt_write_gossip_headers()

int mutt_autocrypt_write_gossip_headers	(	struct Envelope *	env,
		FILE *	fp )

Write the Autocrypt gossip headers to a file.

Parameters

env	Envelope
fp	File to write to

Return values

0	Success
-1	Error

Definition at line 821 of file autocrypt.c.

{
  const bool c_autocrypt = cs_subset_bool(NeoMutt->sub, "autocrypt");
  if (!c_autocrypt || mutt_autocrypt_init(false) || !env)
    return -1;
 
  for (struct AutocryptHeader *gossip = env->autocrypt_gossip; gossip;
       gossip = gossip->next)
  {
    fputs("Autocrypt-Gossip: ", fp);
    write_autocrypt_header_line(fp, gossip->addr, 0, gossip->keydata);
  }
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function: