functions_gpgme.c File Reference

Gpgme functions. More...

#include "config.h"
#include <gpg-error.h>
#include <gpgme.h>
#include <langinfo.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "core/lib.h"
#include "gui/lib.h"
#include "lib.h"
#include "key/lib.h"
#include "menu/lib.h"
#include "pager/lib.h"
#include "question/lib.h"
#include "crypt_gpgme.h"
#include "globals.h"
#include "gpgme_functions.h"
#include "module_data.h"
#include "mutt_logging.h"
#include <libintl.h>

Include dependency graph for functions_gpgme.c:

Go to the source code of this file.

Data Structures
struct	DnArray
	An X500 Distinguished Name. More...

Functions
static void	print_utf8 (FILE *fp, const char *buf, size_t len)
	Write a UTF-8 string to a file.
static bool	print_dn_part (FILE *fp, struct DnArray *dn, const char *key)
	Print the X.500 Distinguished Name.
static void	print_dn_parts (FILE *fp, struct DnArray *dn)
	Print all parts of a DN in a standard sequence.
static const char *	parse_dn_part (struct DnArray *array, const char *str)
	Parse an RDN.
static struct DnArray *	parse_dn (const char *str)
	Parse a DN and return an array-ized one.
static void	parse_and_print_user_id (FILE *fp, const char *userid)
	Print a nice representation of the userid.
static void	print_key_info (gpgme_key_t key, FILE *fp)
	Verbose information about a key or certificate to a file.
static void	verify_key (struct CryptKeyInfo *key)
	Show detailed information about the selected key.
static bool	crypt_key_is_valid (struct CryptKeyInfo *k)
	Is the key valid.
bool	crypt_keys_are_valid (struct CryptKeyInfo *keys)
	Are all these keys valid?
static int	op_quit (struct GpgmeData *gd, const struct KeyEvent *event)
	Save changes and exit this dialog - Implements gpgme_function_t -.
static int	op_generic_select_entry (struct GpgmeData *gd, const struct KeyEvent *event)
	Select the current entry - Implements gpgme_function_t -.
static int	op_verify_key (struct GpgmeData *gd, const struct KeyEvent *event)
	Verify a PGP public key - Implements gpgme_function_t -.
static int	op_view_id (struct GpgmeData *gd, const struct KeyEvent *event)
	View the key's user id - Implements gpgme_function_t -.
int	gpgme_function_dispatcher (struct MuttWindow *win, const struct KeyEvent *event)
	Perform a Gpgme function - Implements function_dispatcher_t -.

Variables
static const char *const	KeyInfoPrompts []
	Names of header fields used in the pgp key display, e.g. Name:, Fingerprint:
static const struct GpgmeFunction	GpgmeFunctions []
	All the NeoMutt functions that the Gpgme supports.

Detailed Description

Gpgme functions.

Authors

• Richard Russon
• Alejandro Colomar
• Thomas Klausner

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 functions_gpgme.c.

Function Documentation

print_utf8()

static void print_utf8 ( FILE * fp, const char * buf, size_t len )

static

Write a UTF-8 string to a file.

Parameters

fp	File to write to
buf	Buffer to read from
len	Length to read

Convert the character set.

Definition at line 84 of file functions_gpgme.c.

{
  char *tstr = MUTT_MEM_MALLOC(len + 1, char);
  memcpy(tstr, buf, len);
  tstr[len] = 0;
 
  /* fromcode "utf-8" is sure, so we don't want
   * charset-hook corrections: flags must be 0.  */
  mutt_ch_convert_string(&tstr, "utf-8", cc_charset(), MUTT_ICONV_NONE);
  fputs(tstr, fp);
  FREE(&tstr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

print_dn_part()

static bool print_dn_part ( FILE * fp, struct DnArray * dn, const char * key )

static

Print the X.500 Distinguished Name.

Parameters

fp	File to write to
dn	Distinguished Name
key	Key string

Return values

true	Any DN keys match the given key string
false	Otherwise

Print the X.500 Distinguished Name part KEY from the array of parts DN to FP.

Definition at line 107 of file functions_gpgme.c.

{
  bool any = false;
 
  for (; dn->key; dn++)
  {
    if (mutt_str_equal(dn->key, key))
    {
      if (any)
        fputs(" + ", fp);
      print_utf8(fp, dn->value, strlen(dn->value));
      any = true;
    }
  }
  return any;
}

Here is the call graph for this function:

Here is the caller graph for this function:

print_dn_parts()

static void print_dn_parts ( FILE * fp, struct DnArray * dn )

static

Print all parts of a DN in a standard sequence.

Parameters

fp	File to write to
dn	Array of Distinguished Names

Definition at line 129 of file functions_gpgme.c.

{
  static const char *const stdpart[] = {
    "CN", "OU", "O", "STREET", "L", "ST", "C", NULL,
  };
  bool any = false;
  bool any2 = false;
 
  for (int i = 0; stdpart[i]; i++)
  {
    if (any)
      fputs(", ", fp);
    any = print_dn_part(fp, dn, stdpart[i]);
  }
  /* now print the rest without any specific ordering */
  for (; dn->key; dn++)
  {
    int i;
    for (i = 0; stdpart[i]; i++)
    {
      if (mutt_str_equal(dn->key, stdpart[i]))
        break;
    }
    if (!stdpart[i])
    {
      if (any)
        fputs(", ", fp);
      if (!any2)
        fputs("(", fp);
      any = print_dn_part(fp, dn, dn->key);
      any2 = true;
    }
  }
  if (any2)
    fputs(")", fp);
}

Here is the call graph for this function:

Here is the caller graph for this function:

parse_dn_part()

static const char * parse_dn_part ( struct DnArray * array, const char * str )

static

Parse an RDN.

Parameters

array	Array for results
str	String to parse

Return values

ptr	First character after Distinguished Name

This is a helper to parse_dn()

Definition at line 174 of file functions_gpgme.c.

{
  const char *s = NULL, *s1 = NULL;
  int n;
  char *p = NULL;
 
  /* parse attribute type */
  for (s = str + 1; (s[0] != '\0') && (s[0] != '='); s++)
    ; // do nothing
 
  if (s[0] == '\0')
    return NULL; /* error */
  n = s - str;
  if (n == 0)
    return NULL; /* empty key */
  array->key = MUTT_MEM_MALLOC(n + 1, char);
  p = array->key;
  memcpy(p, str, n); /* fixme: trim trailing spaces */
  p[n] = 0;
  str = s + 1;
 
  if (*str == '#')
  { /* hexstring */
    str++;
    for (s = str; mutt_isxdigit(*s); s++)
      s++;
    n = s - str;
    if ((n == 0) || (n & 1))
      return NULL; /* empty or odd number of digits */
    n /= 2;
    p = MUTT_MEM_MALLOC(n + 1, char);
    array->value = (char *) p;
    for (s1 = str; n > 0; s1 += 2, n--)
      sscanf(s1, "%2hhx", (unsigned char *) p++);
    *p = '\0';
  }
  else
  { /* regular v3 quoted string */
    for (n = 0, s = str; *s; s++)
    {
      if (*s == '\\')
      { /* pair */
        s++;
        if ((*s == ',') || (*s == '=') || (*s == '+') || (*s == '<') || (*s == '>') ||
            (*s == '#') || (*s == ';') || (*s == '\\') || (*s == '\"') || (*s == ' '))
        {
          n++;
        }
        else if (mutt_isxdigit(s[0]) && mutt_isxdigit(s[1]))
        {
          s++;
          n++;
        }
        else
        {
          return NULL; /* invalid escape sequence */
        }
      }
      else if (*s == '\"')
      {
        return NULL; /* invalid encoding */
      }
      else if ((*s == ',') || (*s == '=') || (*s == '+') || (*s == '<') ||
               (*s == '>') || (*s == '#') || (*s == ';'))
      {
        break;
      }
      else
      {
        n++;
      }
    }
 
    p = MUTT_MEM_MALLOC(n + 1, char);
    array->value = (char *) p;
    for (s = str; n > 0; s++, n--)
    {
      if (*s == '\\')
      {
        s++;
        if (mutt_isxdigit(*s))
        {
          sscanf(s, "%2hhx", (unsigned char *) p++);
          s++;
        }
        else
        {
          *p++ = *s;
        }
      }
      else
      {
        *p++ = *s;
      }
    }
    *p = '\0';
  }
  return s;
}

Here is the call graph for this function:

Here is the caller graph for this function:

parse_dn()

static struct DnArray * parse_dn ( const char * str )

static

Parse a DN and return an array-ized one.

Parameters

str	String to parse

Return values

ptr	Array of Distinguished Names

This is not a validating parser and it does not support any old-stylish syntax; GPGME is expected to return only rfc2253 compatible strings.

Definition at line 282 of file functions_gpgme.c.

{
  struct DnArray *array = NULL;
  size_t arrayidx, arraysize;
 
  arraysize = 7; /* C,ST,L,O,OU,CN,email */
  array = MUTT_MEM_MALLOC(arraysize + 1, struct DnArray);
  arrayidx = 0;
  while (*str)
  {
    while (str[0] == ' ')
      str++;
    if (str[0] == '\0')
      break; /* ready */
    if (arrayidx >= arraysize)
    {
      /* neomutt lacks a real mutt_mem_realloc - so we need to copy */
      arraysize += 5;
      struct DnArray *a2 = MUTT_MEM_MALLOC(arraysize + 1, struct DnArray);
      for (int i = 0; i < arrayidx; i++)
      {
        a2[i].key = array[i].key;
        a2[i].value = array[i].value;
      }
      FREE(&array);
      array = a2;
    }
    array[arrayidx].key = NULL;
    array[arrayidx].value = NULL;
    str = parse_dn_part(array + arrayidx, str);
    arrayidx++;
    if (!str)
      goto failure;
    while (str[0] == ' ')
      str++;
    if ((str[0] != '\0') && (str[0] != ',') && (str[0] != ';') && (str[0] != '+'))
      goto failure; /* invalid delimiter */
    if (str[0] != '\0')
      str++;
  }
  array[arrayidx].key = NULL;
  array[arrayidx].value = NULL;
  return array;
 
failure:
  for (int i = 0; i < arrayidx; i++)
  {
    FREE(&array[i].key);
    FREE(&array[i].value);
  }
  FREE(&array);
  return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

parse_and_print_user_id()

static void parse_and_print_user_id ( FILE * fp, const char * userid )

static

Print a nice representation of the userid.

Parameters

fp	File to write to
userid	String returned by GPGME key functions (utf-8 encoded)

Make sure it is displayed in a proper way, which does mean to reorder some parts for S/MIME's DNs.

Definition at line 344 of file functions_gpgme.c.

{
  const char *s = NULL;
 
  if (*userid == '<')
  {
    s = strchr(userid + 1, '>');
    if (s)
      print_utf8(fp, userid + 1, s - userid - 1);
  }
  else if (*userid == '(')
  {
    fputs(_("[Can't display this user ID (unknown encoding)]"), fp);
  }
  else if (!mutt_isalnum(userid[0]))
  {
    fputs(_("[Can't display this user ID (invalid encoding)]"), fp);
  }
  else
  {
    struct DnArray *dn = parse_dn(userid);
    if (dn)
    {
      print_dn_parts(fp, dn);
      for (int i = 0; dn[i].key; i++)
      {
        FREE(&dn[i].key);
        FREE(&dn[i].value);
      }
      FREE(&dn);
    }
    else
    {
      fputs(_("[Can't display this user ID (invalid DN)]"), fp);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

print_key_info()

static void print_key_info ( gpgme_key_t key, FILE * fp )

static

Verbose information about a key or certificate to a file.

Parameters

key	Key to use
fp	File to write to

Definition at line 387 of file functions_gpgme.c.

{
  struct NcryptModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_NCRYPT);
  int idx;
  const char *s = NULL, *s2 = NULL;
  time_t tt = 0;
  char shortbuf[128] = { 0 };
  unsigned long aval = 0;
  const char *delim = NULL;
  gpgme_user_id_t uid = NULL;
  static int max_header_width = 0;
 
  if (max_header_width == 0)
  {
    for (int i = 0; i < KIP_MAX; i++)
    {
      mod_data->key_info_padding[i] = mutt_str_len(_(KeyInfoPrompts[i]));
      const int width = mutt_strwidth(_(KeyInfoPrompts[i]));
      if (max_header_width < width)
        max_header_width = width;
      mod_data->key_info_padding[i] -= width;
    }
    for (int i = 0; i < KIP_MAX; i++)
      mod_data->key_info_padding[i] += max_header_width;
  }
 
  bool is_pgp = (key->protocol == GPGME_PROTOCOL_OpenPGP);
 
  for (idx = 0, uid = key->uids; uid; idx++, uid = uid->next)
  {
    if (uid->revoked)
      continue;
 
    s = uid->uid;
    /* L10N: DOTFILL */
 
    if (idx == 0)
      fprintf(fp, "%*s", mod_data->key_info_padding[KIP_NAME], _(KeyInfoPrompts[KIP_NAME]));
    else
      fprintf(fp, "%*s", mod_data->key_info_padding[KIP_AKA], _(KeyInfoPrompts[KIP_AKA]));
    if (uid->invalid)
    {
      /* L10N: comes after the Name or aka if the key is invalid */
      fputs(_("[Invalid]"), fp);
      putc(' ', fp);
    }
    if (is_pgp)
      print_utf8(fp, s, strlen(s));
    else
      parse_and_print_user_id(fp, s);
    putc('\n', fp);
  }
 
  if (key->subkeys && (key->subkeys->timestamp > 0))
  {
    tt = key->subkeys->timestamp;
 
    mutt_date_localtime_format(shortbuf, sizeof(shortbuf), nl_langinfo(D_T_FMT), tt);
    fprintf(fp, "%*s%s\n", mod_data->key_info_padding[KIP_VALID_FROM],
            _(KeyInfoPrompts[KIP_VALID_FROM]), shortbuf);
  }
 
  if (key->subkeys && (key->subkeys->expires > 0))
  {
    tt = key->subkeys->expires;
 
    mutt_date_localtime_format(shortbuf, sizeof(shortbuf), nl_langinfo(D_T_FMT), tt);
    fprintf(fp, "%*s%s\n", mod_data->key_info_padding[KIP_VALID_TO],
            _(KeyInfoPrompts[KIP_VALID_TO]), shortbuf);
  }
 
  if (key->subkeys)
    s = gpgme_pubkey_algo_name(key->subkeys->pubkey_algo);
  else
    s = "?";
 
  s2 = is_pgp ? "PGP" : "X.509";
 
  if (key->subkeys)
    aval = key->subkeys->length;
 
  fprintf(fp, "%*s", mod_data->key_info_padding[KIP_KEY_TYPE],
          _(KeyInfoPrompts[KIP_KEY_TYPE]));
  /* L10N: This is printed after "Key Type: " and looks like this: PGP, 2048 bit RSA */
  fprintf(fp, ngettext("%s, %lu bit %s\n", "%s, %lu bit %s\n", aval), s2, aval, s);
 
  fprintf(fp, "%*s", mod_data->key_info_padding[KIP_KEY_USAGE],
          _(KeyInfoPrompts[KIP_KEY_USAGE]));
  delim = "";
 
  if (key_check_cap(key, KEY_CAP_CAN_ENCRYPT))
  {
    /* L10N: value in Key Usage: field */
    fprintf(fp, "%s%s", delim, _("encryption"));
    delim = _(", ");
  }
  if (key_check_cap(key, KEY_CAP_CAN_SIGN))
  {
    /* L10N: value in Key Usage: field */
    fprintf(fp, "%s%s", delim, _("signing"));
    delim = _(", ");
  }
  if (key_check_cap(key, KEY_CAP_CAN_CERTIFY))
  {
    /* L10N: value in Key Usage: field */
    fprintf(fp, "%s%s", delim, _("certification"));
  }
  putc('\n', fp);
 
  if (key->subkeys)
  {
    s = key->subkeys->fpr;
    fprintf(fp, "%*s", mod_data->key_info_padding[KIP_FINGERPRINT],
            _(KeyInfoPrompts[KIP_FINGERPRINT]));
    if (is_pgp && (strlen(s) == 40))
    {
      for (int i = 0; (s[0] != '\0') && (s[1] != '\0') && (s[2] != '\0') &&
                      (s[3] != '\0') && (s[4] != '\0');
           s += 4, i++)
      {
        putc(*s, fp);
        putc(s[1], fp);
        putc(s[2], fp);
        putc(s[3], fp);
        putc(' ', fp);
        if (i == 4)
          putc(' ', fp);
      }
    }
    else
    {
      for (int i = 0; (s[0] != '\0') && (s[1] != '\0') && (s[2] != '\0'); s += 2, i++)
      {
        putc(*s, fp);
        putc(s[1], fp);
        putc(is_pgp ? ' ' : ':', fp);
        if (is_pgp && (i == 7))
          putc(' ', fp);
      }
    }
    fprintf(fp, "%s\n", s);
  }
 
  if (key->issuer_serial)
  {
    s = key->issuer_serial;
    fprintf(fp, "%*s0x%s\n", mod_data->key_info_padding[KIP_SERIAL_NO],
            _(KeyInfoPrompts[KIP_SERIAL_NO]), s);
  }
 
  if (key->issuer_name)
  {
    s = key->issuer_name;
    fprintf(fp, "%*s", mod_data->key_info_padding[KIP_ISSUED_BY],
            _(KeyInfoPrompts[KIP_ISSUED_BY]));
    parse_and_print_user_id(fp, s);
    putc('\n', fp);
  }
 
  /* For PGP we list all subkeys. */
  if (is_pgp)
  {
    gpgme_subkey_t subkey = NULL;
 
    for (idx = 1, subkey = key->subkeys; subkey; idx++, subkey = subkey->next)
    {
      s = subkey->keyid;
 
      putc('\n', fp);
      if (strlen(s) == 16)
        s += 8; /* display only the short keyID */
      fprintf(fp, "%*s0x%s", mod_data->key_info_padding[KIP_SUBKEY],
              _(KeyInfoPrompts[KIP_SUBKEY]), s);
      if (subkey->revoked)
      {
        putc(' ', fp);
        /* L10N: describes a subkey */
        fputs(_("[Revoked]"), fp);
      }
      if (subkey->invalid)
      {
        putc(' ', fp);
        /* L10N: describes a subkey */
        fputs(_("[Invalid]"), fp);
      }
      if (subkey->expired)
      {
        putc(' ', fp);
        /* L10N: describes a subkey */
        fputs(_("[Expired]"), fp);
      }
      if (subkey->disabled)
      {
        putc(' ', fp);
        /* L10N: describes a subkey */
        fputs(_("[Disabled]"), fp);
      }
      putc('\n', fp);
 
      if (subkey->timestamp > 0)
      {
        tt = subkey->timestamp;
 
        mutt_date_localtime_format(shortbuf, sizeof(shortbuf), nl_langinfo(D_T_FMT), tt);
        fprintf(fp, "%*s%s\n", mod_data->key_info_padding[KIP_VALID_FROM],
                _(KeyInfoPrompts[KIP_VALID_FROM]), shortbuf);
      }
 
      if (subkey->expires > 0)
      {
        tt = subkey->expires;
 
        mutt_date_localtime_format(shortbuf, sizeof(shortbuf), nl_langinfo(D_T_FMT), tt);
        fprintf(fp, "%*s%s\n", mod_data->key_info_padding[KIP_VALID_TO],
                _(KeyInfoPrompts[KIP_VALID_TO]), shortbuf);
      }
 
      s = gpgme_pubkey_algo_name(subkey->pubkey_algo);
 
      aval = subkey->length;
 
      fprintf(fp, "%*s", mod_data->key_info_padding[KIP_KEY_TYPE],
              _(KeyInfoPrompts[KIP_KEY_TYPE]));
      /* L10N: This is printed after "Key Type: " and looks like this: PGP, 2048 bit RSA */
      fprintf(fp, ngettext("%s, %lu bit %s\n", "%s, %lu bit %s\n", aval), "PGP", aval, s);
 
      fprintf(fp, "%*s", mod_data->key_info_padding[KIP_KEY_USAGE],
              _(KeyInfoPrompts[KIP_KEY_USAGE]));
      delim = "";
 
      if (subkey->can_encrypt)
      {
        fprintf(fp, "%s%s", delim, _("encryption"));
        delim = _(", ");
      }
      if (subkey->can_sign)
      {
        fprintf(fp, "%s%s", delim, _("signing"));
        delim = _(", ");
      }
      if (subkey->can_certify)
      {
        fprintf(fp, "%s%s", delim, _("certification"));
      }
      putc('\n', fp);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

verify_key()

static void verify_key ( struct CryptKeyInfo * key )

static

Show detailed information about the selected key.

Parameters

key	Key to show

Definition at line 640 of file functions_gpgme.c.

{
  const char *s = NULL;
  gpgme_ctx_t listctx = NULL;
  gpgme_error_t err = GPG_ERR_NO_ERROR;
  gpgme_key_t k = NULL;
  int maxdepth = 100;
 
  struct Buffer *tempfile = buf_pool_get();
  buf_mktemp(tempfile);
  FILE *fp = mutt_file_fopen(buf_string(tempfile), "w");
  if (!fp)
  {
    mutt_perror(_("Can't create temporary file"));
    goto cleanup;
  }
  mutt_message(_("Collecting data..."));
 
  print_key_info(key->kobj, fp);
 
  listctx = create_gpgme_context(key->flags & KEYFLAG_ISX509);
 
  k = key->kobj;
  gpgme_key_ref(k);
  while ((s = k->chain_id) && k->subkeys && !mutt_str_equal(s, k->subkeys->fpr))
  {
    putc('\n', fp);
    err = gpgme_op_keylist_start(listctx, s, 0);
    gpgme_key_unref(k);
    k = NULL;
    if (err == GPG_ERR_NO_ERROR)
      err = gpgme_op_keylist_next(listctx, &k);
    if (err != GPG_ERR_NO_ERROR)
    {
      fprintf(fp, _("Error finding issuer key: %s\n"), gpgme_strerror(err));
      goto leave;
    }
    gpgme_op_keylist_end(listctx);
 
    print_key_info(k, fp);
    if (!--maxdepth)
    {
      putc('\n', fp);
      fputs(_("Error: certification chain too long - stopping here\n"), fp);
      break;
    }
  }
 
leave:
  gpgme_key_unref(k);
  gpgme_release(listctx);
  mutt_file_fclose(&fp);
  mutt_clear_error();
  char title[1024] = { 0 };
  snprintf(title, sizeof(title), _("Key ID: 0x%s"), crypt_keyid(key));
 
  struct PagerData pdata = { 0 };
  struct PagerView pview = { &pdata };
 
  pdata.fname = buf_string(tempfile);
 
  pview.banner = title;
  pview.flags = MUTT_PAGER_NONE;
  pview.mode = PAGER_MODE_OTHER;
 
  mutt_do_pager(&pview, NULL);
 
cleanup:
  buf_pool_release(&tempfile);
}

Here is the call graph for this function:

Here is the caller graph for this function:

crypt_key_is_valid()

static bool crypt_key_is_valid ( struct CryptKeyInfo * k )

static

Is the key valid.

Parameters

k	Key to test

Return values

true	Key is valid

Definition at line 716 of file functions_gpgme.c.

{
  if (k->flags & KEYFLAG_CANTUSE)
    return false;
  return true;
}

Here is the caller graph for this function:

crypt_keys_are_valid()

bool crypt_keys_are_valid

(

struct CryptKeyInfo *

keys

)

Are all these keys valid?

Parameters

keys	Set of keys to test

Return values

true	All keys are valid

Definition at line 728 of file functions_gpgme.c.

{
  for (struct CryptKeyInfo *k = keys; k != NULL; k = k->next)
  {
    if (!crypt_key_is_valid(k))
      return false;
  }
 
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

KeyInfoPrompts

const char* const KeyInfoPrompts[]

static

Initial value:

= {
  
  N_("Name: "),      N_("aka: "),       N_("Valid From: "),  N_("Valid To: "),
  N_("Key Type: "),  N_("Key Usage: "), N_("Fingerprint: "), N_("Serial-No: "),
  N_("Issued By: "), N_("Subkey: ")
}

Names of header fields used in the pgp key display, e.g. Name:, Fingerprint:

Definition at line 58 of file functions_gpgme.c.

                                            {
  /* L10N: The following are the headers for the "verify key" output from the
     GPGME key selection menu (bound to "c" in the key selection menu).
     They will be automatically aligned. */
  N_("Name: "),      N_("aka: "),       N_("Valid From: "),  N_("Valid To: "),
  N_("Key Type: "),  N_("Key Usage: "), N_("Fingerprint: "), N_("Serial-No: "),
  N_("Issued By: "), N_("Subkey: ")
};

GpgmeFunctions

const struct GpgmeFunction GpgmeFunctions[]

static

Initial value:

= {
  
  { OP_EXIT,                   op_quit },
  { OP_GENERIC_SELECT_ENTRY,   op_generic_select_entry },
  { OP_QUIT,                   op_quit },
  { OP_VERIFY_KEY,             op_verify_key },
  { OP_VIEW_ID,                op_view_id },
  { 0, NULL },
  
}

All the NeoMutt functions that the Gpgme supports.

Definition at line 851 of file functions_gpgme.c.

                                                     {
  // clang-format off
  { OP_EXIT,                   op_quit },
  { OP_GENERIC_SELECT_ENTRY,   op_generic_select_entry },
  { OP_QUIT,                   op_quit },
  { OP_VERIFY_KEY,             op_verify_key },
  { OP_VIEW_ID,                op_view_id },
  { 0, NULL },
  // clang-format on
};