lib.h File Reference

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

#include <sqlite3.h>
#include <stdbool.h>
#include <stdio.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
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.

Variables
char *	AutocryptSignAs
	Autocrypt Key id to sign as.
char *	AutocryptDefaultKey
	Autocrypt default key id (used for postponing messages)

Detailed Description

Autocrypt end-to-end encryption.

Authors

• Kevin J. McCarthy

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 156 of file lib.h.

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

Function Documentation

mutt_autocrypt_cleanup()

void mutt_autocrypt_cleanup

(

void

)

Shutdown Autocrypt.

Definition at line 129 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 823 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);
  }
 
  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 97 of file autocrypt.c.

{
  if (AutocryptDB)
    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;
 
  mutt_flushinp();
 
  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 256 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 404 of file autocrypt.c.

{
  struct AutocryptPeer *peer = NULL;
  struct AutocryptGossipHistory *gossip_hist = NULL;
  struct Address *peer_addr = NULL;
  struct Address ac_hdr_addr = { 0 };
  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->env || !prot_headers)
    return 0;
 
  struct Envelope *env = e->env;
 
  struct Address *from = TAILQ_FIRST(&env->from);
  if (!from)
    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;
 
  struct Buffer *keyid = buf_pool_get();
 
  struct AddressList recips = TAILQ_HEAD_INITIALIZER(recips);
 
  /* 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:
  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 697 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) || !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(&AutocryptSignAs, account->keyid);
  mutt_str_replace(&AutocryptDefaultKey, 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 558 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 763 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 801 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:

Variable Documentation

AutocryptSignAs

char* AutocryptSignAs

extern

Autocrypt Key id to sign as.

Definition at line 35 of file config.c.

AutocryptDefaultKey

char* AutocryptDefaultKey

extern

Autocrypt default key id (used for postponing messages)

Definition at line 36 of file config.c.