private.h File Reference

#include "config.h"
#include <stdbool.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.

Functions
struct SmimeKey *	dlg_select_smime_key (struct SmimeKey *keys, char *query)
	Get the user to select a key. More...
struct PgpKeyInfo *	dlg_select_pgp_key (struct PgpKeyInfo *keys, struct Address *p, const char *s)
	Let the user select a key to use. More...
struct CryptKeyInfo *	dlg_select_gpgme_key (struct CryptKeyInfo *keys, struct Address *p, const char *s, unsigned int app, int *forced_valid)
	Get the user to select a key. More...

Variables
bool	C_CryptUsePka
	Config: Use GPGME to use PKA (lookup PGP keys using DNS) More...
bool	C_CryptConfirmHook
	Config: Prompt the user to confirm keys before use. More...
bool	C_CryptOpportunisticEncryptStrongKeys
	Config: Enable encryption only when strong a key is available. More...
bool	C_CryptProtectedHeadersWrite
	Config: Generate protected header (Memory Hole) for signed and encrypted emails. More...
bool	C_PgpIgnoreSubkeys
	Config: Only use the principal PGP key. More...
bool	C_PgpLongIds
	Config: Display long PGP key IDs to the user. More...
bool	C_PgpShowUnusable
	Config: Show non-usable keys in the key selection. More...
bool	C_PgpAutoInline
	Config: Use old-style inline PGP messages (not recommended) More...
char *	C_PgpDefaultKey
	Config: Default key to use for PGP operations. More...
char *	C_PgpEntryFormat
	Config: printf-like format string for the PGP key selection menu. More...
char *	C_SmimeDefaultKey
	Config: Default key for SMIME operations. More...
char *	C_CryptProtectedHeadersSubject
	Config: Use this as the subject for encrypted emails. More...
struct Address *	C_EnvelopeFromAddress
	Config: Manually set the sender for outgoing messages. More...
bool	C_CryptTimestamp
	Config: Add a timestamp to PGP or SMIME output to prevent spoofing. More...
unsigned char	C_PgpEncryptSelf
unsigned char	C_PgpMimeAuto
	Config: Prompt the user to use MIME if inline PGP fails. More...
bool	C_PgpRetainableSigs
	Config: Create nested multipart/signed or encrypted messages. More...
bool	C_PgpSelfEncrypt
	Config: Encrypted messages will also be encrypted to $pgp_default_key too. More...
bool	C_PgpStrictEnc
	Config: Encode PGP signed messages with quoted-printable (don't unset) More...
unsigned char	C_SmimeEncryptSelf
bool	C_SmimeSelfEncrypt
	Config: Encrypted messages will also be encrypt to $smime_default_key too. More...
bool	C_CryptUseGpgme
	Config: Use GPGME crypto backend. More...
bool	C_PgpCheckExit
	Config: Check the exit code of PGP subprocess. More...
bool	C_PgpCheckGpgDecryptStatusFd
	Config: File descriptor used for status info. More...
struct Regex *	C_PgpDecryptionOkay
	Config: Text indicating a successful decryption. More...
struct Regex *	C_PgpGoodSign
	Config: Text indicating a good signature. More...
long	C_PgpTimeout
	Config: Time in seconds to cache a passphrase. More...
bool	C_PgpUseGpgAgent
	Config: Use a PGP agent for caching passwords. More...
char *	C_PgpClearSignCommand
	Config: (pgp) External command to inline-sign a message. More...
char *	C_PgpDecodeCommand
	Config: (pgp) External command to decode a PGP attachment. More...
char *	C_PgpDecryptCommand
	Config: (pgp) External command to decrypt a PGP message. More...
char *	C_PgpEncryptOnlyCommand
	Config: (pgp) External command to encrypt, but not sign a message. More...
char *	C_PgpEncryptSignCommand
	Config: (pgp) External command to encrypt and sign a message. More...
char *	C_PgpExportCommand
	Config: (pgp) External command to export a public key from the user's keyring. More...
char *	C_PgpGetKeysCommand
	Config: (pgp) External command to download a key for an email address. More...
char *	C_PgpImportCommand
	Config: (pgp) External command to import a key into the user's keyring. More...
char *	C_PgpListPubringCommand
	Config: (pgp) External command to list the public keys in a user's keyring. More...
char *	C_PgpListSecringCommand
	Config: (pgp) External command to list the private keys in a user's keyring. More...
char *	C_PgpSignCommand
	Config: (pgp) External command to create a detached PGP signature. More...
char *	C_PgpVerifyCommand
	Config: (pgp) External command to verify PGP signatures. More...
char *	C_PgpVerifyKeyCommand
	Config: (pgp) External command to verify key information. More...
short	C_PgpSortKeys
	Config: Sort order for PGP keys. More...
bool	C_SmimeAskCertLabel
	Config: Prompt the user for a label for SMIME certificates. More...
char *	C_SmimeCaLocation
	Config: File containing trusted certificates. More...
char *	C_SmimeCertificates
	Config: File containing user's public certificates. More...
char *	C_SmimeDecryptCommand
	Config: (smime) External command to decrypt an SMIME message. More...
bool	C_SmimeDecryptUseDefaultKey
	Config: Use the default key for decryption. More...
char *	C_SmimeEncryptCommand
	Config: (smime) External command to encrypt a message. More...
char *	C_SmimeGetCertCommand
	Config: (smime) External command to extract a certificate from a message. More...
char *	C_SmimeGetCertEmailCommand
	Config: (smime) External command to get a certificate for an email. More...
char *	C_SmimeGetSignerCertCommand
	Config: (smime) External command to extract a certificate from an email. More...
char *	C_SmimeImportCertCommand
	Config: (smime) External command to import a certificate. More...
char *	C_SmimeKeys
	Config: File containing user's private certificates. More...
char *	C_SmimePk7outCommand
	Config: (smime) External command to extract a public certificate. More...
char *	C_SmimeSignCommand
	Config: (smime) External command to sign a message. More...
char *	C_SmimeSignDigestAlg
	Config: Digest algorithm. More...
long	C_SmimeTimeout
	Config: Time in seconds to cache a passphrase. More...
char *	C_SmimeVerifyCommand
	Config: (smime) External command to verify a signed message. More...
char *	C_SmimeVerifyOpaqueCommand
	Config: (smime) External command to verify a signature. More...

Detailed Description

Shared constants/structs that are private to libconn

Authors

• 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.

Function Documentation

dlg_select_smime_key()

struct SmimeKey* dlg_select_smime_key	(	struct SmimeKey *	keys,
		char *	query
	)

Get the user to select a key.

Parameters

keys	List of keys to select from
query	String to match

Return values

ptr	Key selected by user

Definition at line 157 of file dlgsmime.c.

{
  struct SmimeKey **table = NULL;
  int table_size = 0;
  int table_index = 0;
  struct SmimeKey *key = NULL;
  struct SmimeKey *selected_key = NULL;
  char buf[1024];
  char title[256];
  struct Menu *menu = NULL;
  const char *s = "";
  bool done = false;
 
  for (table_index = 0, key = keys; key; key = key->next)
  {
    if (table_index == table_size)
    {
      table_size += 5;
      mutt_mem_realloc(&table, sizeof(struct SmimeKey *) * table_size);
    }
 
    table[table_index++] = key;
  }
 
  snprintf(title, sizeof(title), _("S/MIME certificates matching \"%s\""), query);
 
  menu = mutt_menu_new(MENU_SMIME);
  struct MuttWindow *dlg = dialog_create_simple_index(menu, WT_DLG_SMIME);
  dlg->help_data = SmimeHelp;
  dlg->help_menu = MENU_SMIME;
 
  menu->max = table_index;
  menu->make_entry = smime_make_entry;
  menu->mdata = table;
  menu->title = title;
  mutt_menu_push_current(menu);
  /* sorting keys might be done later - TODO */
 
  mutt_clear_error();
 
  done = false;
  while (!done)
  {
    switch (mutt_menu_loop(menu))
    {
      case OP_GENERIC_SELECT_ENTRY:
        if (table[menu->current]->trust != 't')
        {
          switch (table[menu->current]->trust)
          {
            case 'e':
            case 'i':
            case 'r':
              s = _("ID is expired/disabled/revoked. Do you really want to use "
                    "the key?");
              break;
            case 'u':
              s = _("ID has undefined validity. Do you really want to use the "
                    "key?");
              break;
            case 'v':
              s = _("ID is not trusted. Do you really want to use the key?");
              break;
          }
 
          snprintf(buf, sizeof(buf), "%s", s);
 
          if (mutt_yesorno(buf, MUTT_NO) != MUTT_YES)
          {
            mutt_clear_error();
            break;
          }
        }
 
        selected_key = table[menu->current];
        done = true;
        break;
      case OP_EXIT:
        done = true;
        break;
    }
  }
 
  mutt_menu_pop_current(menu);
  mutt_menu_free(&menu);
  dialog_destroy_simple_index(&dlg);
  FREE(&table);
 
  return selected_key;
}

Here is the call graph for this function:

Here is the caller graph for this function:

dlg_select_pgp_key()

struct PgpKeyInfo* dlg_select_pgp_key	(	struct PgpKeyInfo *	keys,
		struct Address *	p,
		const char *	s
	)

Let the user select a key to use.

Parameters

keys	List of PGP keys
p	Address to match
s	String to match

Return values

ptr	Selected PGP key

Definition at line 469 of file dlgpgp.c.

{
  struct PgpUid **key_table = NULL;
  struct Menu *menu = NULL;
  int i;
  bool done = false;
  char buf[1024], tmpbuf[256];
  struct PgpKeyInfo *kp = NULL;
  struct PgpUid *a = NULL;
  struct Buffer *tempfile = NULL;
 
  bool unusable = false;
 
  int keymax = 0;
 
  for (i = 0, kp = keys; kp; kp = kp->next)
  {
    if (!C_PgpShowUnusable && (kp->flags & KEYFLAG_CANTUSE))
    {
      unusable = true;
      continue;
    }
 
    for (a = kp->address; a; a = a->next)
    {
      if (!C_PgpShowUnusable && (a->flags & KEYFLAG_CANTUSE))
      {
        unusable = true;
        continue;
      }
 
      if (i == keymax)
      {
        keymax += 5;
        mutt_mem_realloc(&key_table, sizeof(struct PgpUid *) * keymax);
      }
 
      key_table[i++] = a;
    }
  }
 
  if ((i == 0) && unusable)
  {
    mutt_error(_("All matching keys are expired, revoked, or disabled"));
    return NULL;
  }
 
  int (*f)(const void *, const void *);
  switch (C_PgpSortKeys & SORT_MASK)
  {
    case SORT_ADDRESS:
      f = pgp_compare_address_qsort;
      break;
    case SORT_DATE:
      f = pgp_compare_date_qsort;
      break;
    case SORT_KEYID:
      f = pgp_compare_keyid_qsort;
      break;
    case SORT_TRUST:
    default:
      f = pgp_compare_trust_qsort;
      break;
  }
  qsort(key_table, i, sizeof(struct PgpUid *), f);
 
  menu = mutt_menu_new(MENU_PGP);
  struct MuttWindow *dlg = dialog_create_simple_index(menu, WT_DLG_PGP);
  dlg->help_data = PgpHelp;
  dlg->help_menu = MENU_PGP;
 
  menu->max = i;
  menu->make_entry = pgp_make_entry;
  menu->mdata = key_table;
  mutt_menu_push_current(menu);
 
  if (p)
    snprintf(buf, sizeof(buf), _("PGP keys matching <%s>"), p->mailbox);
  else
    snprintf(buf, sizeof(buf), _("PGP keys matching \"%s\""), s);
 
  menu->title = buf;
 
  kp = NULL;
 
  mutt_clear_error();
 
  while (!done)
  {
    switch (mutt_menu_loop(menu))
    {
      case OP_VERIFY_KEY:
      {
        FILE *fp_null = fopen("/dev/null", "w");
        if (!fp_null)
        {
          mutt_perror(_("Can't open /dev/null"));
          break;
        }
        tempfile = mutt_buffer_pool_get();
        mutt_buffer_mktemp(tempfile);
        FILE *fp_tmp = mutt_file_fopen(mutt_buffer_string(tempfile), "w");
        if (!fp_tmp)
        {
          mutt_perror(_("Can't create temporary file"));
          mutt_file_fclose(&fp_null);
          mutt_buffer_pool_release(&tempfile);
          break;
        }
 
        mutt_message(_("Invoking PGP..."));
 
        snprintf(tmpbuf, sizeof(tmpbuf), "0x%s",
                 pgp_fpr_or_lkeyid(pgp_principal_key(key_table[menu->current]->parent)));
 
        pid_t pid = pgp_invoke_verify_key(NULL, NULL, NULL, -1, fileno(fp_tmp),
                                          fileno(fp_null), tmpbuf);
        if (pid == -1)
        {
          mutt_perror(_("Can't create filter"));
          unlink(mutt_buffer_string(tempfile));
          mutt_file_fclose(&fp_tmp);
          mutt_file_fclose(&fp_null);
        }
 
        filter_wait(pid);
        mutt_file_fclose(&fp_tmp);
        mutt_file_fclose(&fp_null);
        mutt_clear_error();
        char title[1024];
        snprintf(title, sizeof(title), _("Key ID: 0x%s"),
                 pgp_keyid(pgp_principal_key(key_table[menu->current]->parent)));
        mutt_do_pager(title, mutt_buffer_string(tempfile), MUTT_PAGER_NO_FLAGS, NULL);
        mutt_buffer_pool_release(&tempfile);
        menu->redraw = REDRAW_FULL;
        break;
      }
 
      case OP_VIEW_ID:
 
        mutt_message("%s", NONULL(key_table[menu->current]->addr));
        break;
 
      case OP_GENERIC_SELECT_ENTRY:
 
        /* XXX make error reporting more verbose */
 
        if (OptPgpCheckTrust)
        {
          if (!pgp_key_is_valid(key_table[menu->current]->parent))
          {
            mutt_error(_("This key can't be used: expired/disabled/revoked"));
            break;
          }
        }
 
        if (OptPgpCheckTrust && (!pgp_id_is_valid(key_table[menu->current]) ||
                                 !pgp_id_is_strong(key_table[menu->current])))
        {
          const char *str = "";
          char buf2[1024];
 
          if (key_table[menu->current]->flags & KEYFLAG_CANTUSE)
          {
            str = _("ID is expired/disabled/revoked. Do you really want to use "
                    "the key?");
          }
          else
          {
            switch (key_table[menu->current]->trust & 0x03)
            {
              case 0:
                str = _("ID has undefined validity. Do you really want to use "
                        "the key?");
                break;
              case 1:
                str = _("ID is not valid. Do you really want to use the key?");
                break;
              case 2:
                str = _("ID is only marginally valid. Do you really want to "
                        "use the key?");
                break;
            }
          }
 
          snprintf(buf2, sizeof(buf2), "%s", str);
 
          if (mutt_yesorno(buf2, MUTT_NO) != MUTT_YES)
          {
            mutt_clear_error();
            break;
          }
        }
 
        kp = key_table[menu->current]->parent;
        done = true;
        break;
 
      case OP_EXIT:
 
        kp = NULL;
        done = true;
        break;
    }
  }
 
  mutt_menu_pop_current(menu);
  mutt_menu_free(&menu);
  dialog_destroy_simple_index(&dlg);
  FREE(&key_table);
 
  return kp;
}

Here is the call graph for this function:

Here is the caller graph for this function:

dlg_select_gpgme_key()

struct CryptKeyInfo* dlg_select_gpgme_key	(	struct CryptKeyInfo *	keys,
		struct Address *	p,
		const char *	s,
		unsigned int	app,
		int *	forced_valid
	)

Get the user to select a key.

Parameters

[in]	keys	List of keys to select from
[in]	p	Address to match
[in]	s	Real name to display
[in]	app	Flags, e.g. APPLICATION_PGP
[out]	forced_valid	Set to true if user overrode key's validity

Return values

ptr	Key selected by user

Display a menu to select a key from the array of keys.

Definition at line 1196 of file dlggpgme.c.

{
  int keymax;
  int i;
  bool done = false;
  char buf[1024];
  struct CryptKeyInfo *k = NULL;
  int (*f)(const void *, const void *);
  enum MenuType menu_to_use = MENU_GENERIC;
  bool unusable = false;
 
  *forced_valid = 0;
 
  /* build the key table */
  keymax = 0;
  i = 0;
  struct CryptKeyInfo **key_table = NULL;
  for (k = keys; k; k = k->next)
  {
    if (!C_PgpShowUnusable && (k->flags & KEYFLAG_CANTUSE))
    {
      unusable = true;
      continue;
    }
 
    if (i == keymax)
    {
      keymax += 20;
      mutt_mem_realloc(&key_table, sizeof(struct CryptKeyInfo *) * keymax);
    }
 
    key_table[i++] = k;
  }
 
  if (!i && unusable)
  {
    mutt_error(_("All matching keys are marked expired/revoked"));
    return NULL;
  }
 
  switch (C_PgpSortKeys & SORT_MASK)
  {
    case SORT_ADDRESS:
      f = crypt_compare_address_qsort;
      break;
    case SORT_DATE:
      f = crypt_compare_date_qsort;
      break;
    case SORT_KEYID:
      f = crypt_crypt_compare_keyid_qsort;
      break;
    case SORT_TRUST:
    default:
      f = crypt_compare_trust_qsort;
      break;
  }
  qsort(key_table, i, sizeof(struct CryptKeyInfo *), f);
 
  if (app & APPLICATION_PGP)
    menu_to_use = MENU_KEY_SELECT_PGP;
  else if (app & APPLICATION_SMIME)
    menu_to_use = MENU_KEY_SELECT_SMIME;
 
  struct Menu *menu = mutt_menu_new(menu_to_use);
  struct MuttWindow *dlg = dialog_create_simple_index(menu, WT_DLG_CRYPT_GPGME);
  dlg->help_data = GpgmeHelp;
  dlg->help_menu = menu_to_use;
 
  menu->max = i;
  menu->make_entry = crypt_make_entry;
  menu->mdata = key_table;
  mutt_menu_push_current(menu);
 
  {
    const char *ts = NULL;
 
    if ((app & APPLICATION_PGP) && (app & APPLICATION_SMIME))
      ts = _("PGP and S/MIME keys matching");
    else if ((app & APPLICATION_PGP))
      ts = _("PGP keys matching");
    else if ((app & APPLICATION_SMIME))
      ts = _("S/MIME keys matching");
    else
      ts = _("keys matching");
 
    if (p)
    {
      /* L10N: 1$s is one of the previous four entries.
         %2$s is an address.
         e.g. "S/MIME keys matching <me@mutt.org>" */
      snprintf(buf, sizeof(buf), _("%s <%s>"), ts, p->mailbox);
    }
    else
    {
      /* L10N: e.g. 'S/MIME keys matching "Michael Elkins".' */
      snprintf(buf, sizeof(buf), _("%s \"%s\""), ts, s);
    }
    menu->title = buf;
  }
 
  mutt_clear_error();
  k = NULL;
  while (!done)
  {
    *forced_valid = 0;
    switch (mutt_menu_loop(menu))
    {
      case OP_VERIFY_KEY:
        verify_key(key_table[menu->current]);
        menu->redraw = REDRAW_FULL;
        break;
 
      case OP_VIEW_ID:
        mutt_message("%s", key_table[menu->current]->uid);
        break;
 
      case OP_GENERIC_SELECT_ENTRY:
        /* FIXME make error reporting more verbose - this should be
         * easy because GPGME provides more information */
        if (OptPgpCheckTrust)
        {
          if (!crypt_key_is_valid(key_table[menu->current]))
          {
            mutt_error(_("This key can't be used: "
                         "expired/disabled/revoked"));
            break;
          }
        }
 
        if (OptPgpCheckTrust && (!crypt_id_is_valid(key_table[menu->current]) ||
                                 !crypt_id_is_strong(key_table[menu->current])))
        {
          const char *warn_s = NULL;
          char buf2[1024];
 
          if (key_table[menu->current]->flags & KEYFLAG_CANTUSE)
          {
            warn_s = _("ID is expired/disabled/revoked. Do you really want to "
                       "use the key?");
          }
          else
          {
            warn_s = "??";
            switch (key_table[menu->current]->validity)
            {
              case GPGME_VALIDITY_NEVER:
                warn_s =
                    _("ID is not valid. Do you really want to use the key?");
                break;
              case GPGME_VALIDITY_MARGINAL:
                warn_s = _("ID is only marginally valid. Do you really want to "
                           "use the key?");
                break;
              case GPGME_VALIDITY_FULL:
              case GPGME_VALIDITY_ULTIMATE:
                break;
              case GPGME_VALIDITY_UNKNOWN:
              case GPGME_VALIDITY_UNDEFINED:
                warn_s = _("ID has undefined validity. Do you really want to "
                           "use the key?");
                break;
            }
          }
 
          snprintf(buf2, sizeof(buf2), "%s", warn_s);
 
          if (mutt_yesorno(buf2, MUTT_NO) != MUTT_YES)
          {
            mutt_clear_error();
            break;
          }
 
          /* A '!' is appended to a key in find_keys() when forced_valid is
           * set.  Prior to GPGME 1.11.0, encrypt_gpgme_object() called
           * create_recipient_set() which interpreted the '!' to mean set
           * GPGME_VALIDITY_FULL for the key.
           *
           * Starting in GPGME 1.11.0, we now use a '\n' delimited recipient
           * string, which is passed directly to the gpgme_op_encrypt_ext()
           * function.  This allows to use the original meaning of '!' to
           * force a subkey use. */
#if (GPGME_VERSION_NUMBER < 0x010b00) /* GPGME < 1.11.0 */
          *forced_valid = 1;
#endif
        }
 
        k = crypt_copy_key(key_table[menu->current]);
        done = true;
        break;
 
      case OP_EXIT:
        k = NULL;
        done = true;
        break;
    }
  }
 
  mutt_menu_pop_current(menu);
  mutt_menu_free(&menu);
  dialog_destroy_simple_index(&dlg);
  FREE(&key_table);
 
  return k;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

C_CryptUsePka

bool C_CryptUsePka

Config: Use GPGME to use PKA (lookup PGP keys using DNS)

Definition at line 51 of file config.c.

C_CryptConfirmHook

bool C_CryptConfirmHook

Config: Prompt the user to confirm keys before use.

Definition at line 53 of file config.c.

C_CryptOpportunisticEncryptStrongKeys

bool C_CryptOpportunisticEncryptStrongKeys

Config: Enable encryption only when strong a key is available.

Definition at line 55 of file config.c.

C_CryptProtectedHeadersWrite

bool C_CryptProtectedHeadersWrite

Config: Generate protected header (Memory Hole) for signed and encrypted emails.

Definition at line 58 of file config.c.

C_PgpIgnoreSubkeys

bool C_PgpIgnoreSubkeys

Config: Only use the principal PGP key.

Definition at line 60 of file config.c.

C_PgpLongIds

bool C_PgpLongIds

Config: Display long PGP key IDs to the user.

Definition at line 61 of file config.c.

C_PgpShowUnusable

bool C_PgpShowUnusable

Config: Show non-usable keys in the key selection.

Definition at line 62 of file config.c.

C_PgpAutoInline

bool C_PgpAutoInline

Config: Use old-style inline PGP messages (not recommended)

Definition at line 63 of file config.c.

C_PgpDefaultKey

char* C_PgpDefaultKey

Config: Default key to use for PGP operations.

Definition at line 64 of file config.c.

C_PgpEntryFormat

char* C_PgpEntryFormat

Config: printf-like format string for the PGP key selection menu.

Definition at line 66 of file config.c.

C_SmimeDefaultKey

char* C_SmimeDefaultKey

Config: Default key for SMIME operations.

Definition at line 67 of file config.c.

C_CryptProtectedHeadersSubject

char* C_CryptProtectedHeadersSubject

Config: Use this as the subject for encrypted emails.

Definition at line 70 of file config.c.

C_EnvelopeFromAddress

struct Address* C_EnvelopeFromAddress

Config: Manually set the sender for outgoing messages.

Definition at line 71 of file config.c.

C_CryptTimestamp

bool C_CryptTimestamp

Config: Add a timestamp to PGP or SMIME output to prevent spoofing.

Definition at line 72 of file config.c.

C_PgpEncryptSelf

unsigned char C_PgpEncryptSelf

Definition at line 73 of file config.c.

C_PgpMimeAuto

unsigned char C_PgpMimeAuto

Config: Prompt the user to use MIME if inline PGP fails.

Definition at line 74 of file config.c.

C_PgpRetainableSigs

bool C_PgpRetainableSigs

Config: Create nested multipart/signed or encrypted messages.

Definition at line 75 of file config.c.

C_PgpSelfEncrypt

bool C_PgpSelfEncrypt

Config: Encrypted messages will also be encrypted to $pgp_default_key too.

Definition at line 76 of file config.c.

C_PgpStrictEnc

bool C_PgpStrictEnc

Config: Encode PGP signed messages with quoted-printable (don't unset)

Definition at line 77 of file config.c.

C_SmimeEncryptSelf

unsigned char C_SmimeEncryptSelf

Definition at line 78 of file config.c.

C_SmimeSelfEncrypt

bool C_SmimeSelfEncrypt

Config: Encrypted messages will also be encrypt to $smime_default_key too.

Definition at line 79 of file config.c.

C_CryptUseGpgme

bool C_CryptUseGpgme

Config: Use GPGME crypto backend.

Definition at line 81 of file config.c.

C_PgpCheckExit

bool C_PgpCheckExit

Config: Check the exit code of PGP subprocess.

Definition at line 83 of file config.c.

C_PgpCheckGpgDecryptStatusFd

bool C_PgpCheckGpgDecryptStatusFd

Config: File descriptor used for status info.

Definition at line 84 of file config.c.

C_PgpDecryptionOkay

struct Regex* C_PgpDecryptionOkay

Config: Text indicating a successful decryption.

Definition at line 85 of file config.c.

C_PgpGoodSign

struct Regex* C_PgpGoodSign

Config: Text indicating a good signature.

Definition at line 86 of file config.c.

C_PgpTimeout

long C_PgpTimeout

Config: Time in seconds to cache a passphrase.

Definition at line 87 of file config.c.

C_PgpUseGpgAgent

bool C_PgpUseGpgAgent

Config: Use a PGP agent for caching passwords.

Definition at line 88 of file config.c.

C_PgpClearSignCommand

char* C_PgpClearSignCommand

Config: (pgp) External command to inline-sign a message.

Definition at line 89 of file config.c.

C_PgpDecodeCommand

char* C_PgpDecodeCommand

Config: (pgp) External command to decode a PGP attachment.

Definition at line 90 of file config.c.

C_PgpDecryptCommand

char* C_PgpDecryptCommand

Config: (pgp) External command to decrypt a PGP message.

Definition at line 91 of file config.c.

C_PgpEncryptOnlyCommand

char* C_PgpEncryptOnlyCommand

Config: (pgp) External command to encrypt, but not sign a message.

Definition at line 92 of file config.c.

C_PgpEncryptSignCommand

char* C_PgpEncryptSignCommand

Config: (pgp) External command to encrypt and sign a message.

Definition at line 93 of file config.c.

C_PgpExportCommand

char* C_PgpExportCommand

Config: (pgp) External command to export a public key from the user's keyring.

Definition at line 94 of file config.c.

C_PgpGetKeysCommand

char* C_PgpGetKeysCommand

Config: (pgp) External command to download a key for an email address.

Definition at line 95 of file config.c.

C_PgpImportCommand

char* C_PgpImportCommand

Config: (pgp) External command to import a key into the user's keyring.

Definition at line 96 of file config.c.

C_PgpListPubringCommand

char* C_PgpListPubringCommand

Config: (pgp) External command to list the public keys in a user's keyring.

Definition at line 97 of file config.c.

C_PgpListSecringCommand

char* C_PgpListSecringCommand

Config: (pgp) External command to list the private keys in a user's keyring.

Definition at line 98 of file config.c.

C_PgpSignCommand

char* C_PgpSignCommand

Config: (pgp) External command to create a detached PGP signature.

Definition at line 99 of file config.c.

C_PgpVerifyCommand

char* C_PgpVerifyCommand

Config: (pgp) External command to verify PGP signatures.

Definition at line 100 of file config.c.

C_PgpVerifyKeyCommand

char* C_PgpVerifyKeyCommand

Config: (pgp) External command to verify key information.

Definition at line 101 of file config.c.

C_PgpSortKeys

short C_PgpSortKeys

Config: Sort order for PGP keys.

Definition at line 102 of file config.c.

C_SmimeAskCertLabel

bool C_SmimeAskCertLabel

Config: Prompt the user for a label for SMIME certificates.

Definition at line 103 of file config.c.

C_SmimeCaLocation

char* C_SmimeCaLocation

Config: File containing trusted certificates.

Definition at line 104 of file config.c.

C_SmimeCertificates

char* C_SmimeCertificates

Config: File containing user's public certificates.

Definition at line 105 of file config.c.

C_SmimeDecryptCommand

char* C_SmimeDecryptCommand

Config: (smime) External command to decrypt an SMIME message.

Definition at line 106 of file config.c.

C_SmimeDecryptUseDefaultKey

bool C_SmimeDecryptUseDefaultKey

Config: Use the default key for decryption.

Definition at line 107 of file config.c.

C_SmimeEncryptCommand

char* C_SmimeEncryptCommand

Config: (smime) External command to encrypt a message.

Definition at line 108 of file config.c.

C_SmimeGetCertCommand

char* C_SmimeGetCertCommand

Config: (smime) External command to extract a certificate from a message.

Definition at line 109 of file config.c.

C_SmimeGetCertEmailCommand

char* C_SmimeGetCertEmailCommand

Config: (smime) External command to get a certificate for an email.

Definition at line 110 of file config.c.

C_SmimeGetSignerCertCommand

char* C_SmimeGetSignerCertCommand

Config: (smime) External command to extract a certificate from an email.

Definition at line 111 of file config.c.

C_SmimeImportCertCommand

char* C_SmimeImportCertCommand

Config: (smime) External command to import a certificate.

Definition at line 112 of file config.c.

C_SmimeKeys

char* C_SmimeKeys

Config: File containing user's private certificates.

Definition at line 113 of file config.c.

C_SmimePk7outCommand

char* C_SmimePk7outCommand

Config: (smime) External command to extract a public certificate.

Definition at line 114 of file config.c.

C_SmimeSignCommand

char* C_SmimeSignCommand

Config: (smime) External command to sign a message.

Definition at line 115 of file config.c.

C_SmimeSignDigestAlg

char* C_SmimeSignDigestAlg

Config: Digest algorithm.

Definition at line 116 of file config.c.

C_SmimeTimeout

long C_SmimeTimeout

Config: Time in seconds to cache a passphrase.

Definition at line 117 of file config.c.

C_SmimeVerifyCommand

char* C_SmimeVerifyCommand

Config: (smime) External command to verify a signed message.

Definition at line 118 of file config.c.

C_SmimeVerifyOpaqueCommand

char* C_SmimeVerifyOpaqueCommand

Config: (smime) External command to verify a signature.

Definition at line 119 of file config.c.