gpgme_functions.c File Reference

Gpgme functions. More...

#include "config.h"
#include <gpg-error.h>
#include <gpgme.h>
#include <langinfo.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 "gpgme_functions.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 "mutt_logging.h"
#include <libintl.h>

Include dependency graph for gpgme_functions.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_exit (struct GpgmeData *gd, const struct KeyEvent *event)
	Exit this menu - 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
int	KeyInfoPadding [KIP_MAX] = { 0 }
	Number of padding spaces needed after each of the strings in KeyInfoPrompts after translation.
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 gpgme_functions.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 85 of file gpgme_functions.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_NO_FLAGS);
  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 108 of file gpgme_functions.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 130 of file gpgme_functions.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 175 of file gpgme_functions.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 283 of file gpgme_functions.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 345 of file gpgme_functions.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 388 of file gpgme_functions.c.

{
  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++)
    {
      KeyInfoPadding[i] = mutt_str_len(_(KeyInfoPrompts[i]));
      const int width = mutt_strwidth(_(KeyInfoPrompts[i]));
      if (max_header_width < width)
        max_header_width = width;
      KeyInfoPadding[i] -= width;
    }
    for (int i = 0; i < KIP_MAX; i++)
      KeyInfoPadding[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", KeyInfoPadding[KIP_NAME], _(KeyInfoPrompts[KIP_NAME]));
    else
      fprintf(fp, "%*s", KeyInfoPadding[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", KeyInfoPadding[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", KeyInfoPadding[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", KeyInfoPadding[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", KeyInfoPadding[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", KeyInfoPadding[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", KeyInfoPadding[KIP_SERIAL_NO],
            _(KeyInfoPrompts[KIP_SERIAL_NO]), s);
  }
 
  if (key->issuer_name)
  {
    s = key->issuer_name;
    fprintf(fp, "%*s", KeyInfoPadding[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", KeyInfoPadding[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", KeyInfoPadding[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", KeyInfoPadding[KIP_VALID_TO],
                _(KeyInfoPrompts[KIP_VALID_TO]), shortbuf);
      }
 
      s = gpgme_pubkey_algo_name(subkey->pubkey_algo);
 
      aval = subkey->length;
 
      fprintf(fp, "%*s", KeyInfoPadding[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", KeyInfoPadding[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 633 of file gpgme_functions.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_NO_FLAGS;
  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 709 of file gpgme_functions.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 721 of file gpgme_functions.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

KeyInfoPadding

int KeyInfoPadding[KIP_MAX] = { 0 }

Number of padding spaces needed after each of the strings in KeyInfoPrompts after translation.

Definition at line 56 of file gpgme_functions.c.

{ 0 };

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 59 of file gpgme_functions.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_exit },
  { OP_GENERIC_SELECT_ENTRY,   op_generic_select_entry },
  { 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 844 of file gpgme_functions.c.

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