dlg_smime.c

Go to the documentation of this file.

 
#include "config.h"
#include <stdbool.h>
#include <stdio.h>
#include "private.h"
#include "mutt/lib.h"
#include "core/lib.h"
#include "gui/lib.h"
#include "lib.h"
#include "key/lib.h"
#include "menu/lib.h"
#include "module_data.h"
#include "mutt_logging.h"
#include "smime.h"
#include "smime_functions.h"

static const struct Mapping SmimeHelp[] = {
  // clang-format off
  { N_("Exit"),   OP_EXIT },
  { N_("Select"), OP_GENERIC_SELECT_ENTRY },
  { N_("Help"),   OP_HELP },
  { NULL, 0 },
  // clang-format on
};

static char *smime_key_flags(KeyFlags flags)
{
  static char buf[3];
 
  if (!(flags & KEYFLAG_CANENCRYPT))
    buf[0] = '-';
  else
    buf[0] = 'e';
 
  if (!(flags & KEYFLAG_CANSIGN))
    buf[1] = '-';
  else
    buf[1] = 's';
 
  buf[2] = '\0';
 
  return buf;
}

static int smime_make_entry(struct Menu *menu, int line, int max_cols, struct Buffer *buf)
{
  struct SmimeData *sd = menu->mdata;
  struct SmimeKey **pkey = ARRAY_GET(sd->ska, line);
  if (!pkey)
    return 0;
 
  char *truststate = NULL;
  switch ((*pkey)->trust)
  {
    case 'e':
      /* L10N: Describes the trust state of a S/MIME key.
         This translation must be padded with spaces to the right such that it
         has the same length as the other translations.
         The translation strings which need to be padded are:
         Expired, Invalid, Revoked, Trusted, Unverified, Verified, and Unknown.  */
      truststate = _("Expired   ");
      break;
    case 'i':
      /* L10N: Describes the trust state of a S/MIME key.
         This translation must be padded with spaces to the right such that it
         has the same length as the other translations.
         The translation strings which need to be padded are:
         Expired, Invalid, Revoked, Trusted, Unverified, Verified, and Unknown.  */
      truststate = _("Invalid   ");
      break;
    case 'r':
      /* L10N: Describes the trust state of a S/MIME key.
         This translation must be padded with spaces to the right such that it
         has the same length as the other translations.
         The translation strings which need to be padded are:
         Expired, Invalid, Revoked, Trusted, Unverified, Verified, and Unknown.  */
      truststate = _("Revoked   ");
      break;
    case 't':
      /* L10N: Describes the trust state of a S/MIME key.
         This translation must be padded with spaces to the right such that it
         has the same length as the other translations.
         The translation strings which need to be padded are:
         Expired, Invalid, Revoked, Trusted, Unverified, Verified, and Unknown.  */
      truststate = _("Trusted   ");
      break;
    case 'u':
      /* L10N: Describes the trust state of a S/MIME key.
         This translation must be padded with spaces to the right such that it
         has the same length as the other translations.
         The translation strings which need to be padded are:
         Expired, Invalid, Revoked, Trusted, Unverified, Verified, and Unknown.  */
      truststate = _("Unverified");
      break;
    case 'v':
      /* L10N: Describes the trust state of a S/MIME key.
         This translation must be padded with spaces to the right such that it
         has the same length as the other translations.
         The translation strings which need to be padded are:
         Expired, Invalid, Revoked, Trusted, Unverified, Verified, and Unknown.  */
      truststate = _("Verified  ");
      break;
    default:
      /* L10N: Describes the trust state of a S/MIME key.
         This translation must be padded with spaces to the right such that it
         has the same length as the other translations.
         The translation strings which need to be padded are:
         Expired, Invalid, Revoked, Trusted, Unverified, Verified, and Unknown.  */
      truststate = _("Unknown   ");
  }
 
  int bytes = buf_printf(buf, " 0x%s %s %s %-35.35s %s", (*pkey)->hash,
                         smime_key_flags((*pkey)->flags), truststate,
                         (*pkey)->email, (*pkey)->label);
  if (bytes < 0)
    bytes = 0;
 
  return mutt_strnwidth(buf_string(buf), bytes);
}

struct SmimeKey *dlg_smime(struct SmimeKey *keys, const char *query)
{
  struct SmimeKeyArray ska = ARRAY_HEAD_INITIALIZER;
  for (struct SmimeKey *key = keys; key; key = key->next)
  {
    ARRAY_ADD(&ska, key);
  }
  /* sorting keys might be done later - TODO */
 
  struct NcryptModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_NCRYPT);
  ASSERT(mod_data);
 
  struct SimpleDialogWindows sdw = simple_dialog_new(mod_data->menu_smime,
                                                     WT_DLG_SMIME, SmimeHelp);
  struct Menu *menu = sdw.menu;
 
  struct SmimeData sd = { false, menu, &ska, NULL };
 
  menu->max = ARRAY_SIZE(&ska);
  menu->make_entry = smime_make_entry;
  menu->mdata = &sd;
  menu->mdata_free = NULL; // Menu doesn't own the data
 
  char title[256] = { 0 };
  snprintf(title, sizeof(title), _("S/MIME certificates matching \"%s\""), query);
  sbar_set_title(sdw.sbar, title);
 
  mutt_clear_error();
 
  struct MuttWindow *old_focus = window_set_focus(menu->win);
  // ---------------------------------------------------------------------------
  // Event Loop
  int op = OP_NULL;
  struct KeyEvent event = { 0, OP_NULL };
  do
  {
    menu_tagging_dispatcher(menu->win, &event);
    window_redraw(NULL);
 
    event = km_dokey(mod_data->menu_smime, GETCH_NONE);
    op = event.op;
    mutt_debug(LL_DEBUG1, "Got op %s (%d)\n", opcodes_get_name(op), op);
    if (op < 0)
      continue;
    if (op == OP_NULL)
    {
      km_error_key(mod_data->menu_smime);
      continue;
    }
    mutt_clear_error();
 
    int rc = smime_function_dispatcher(sdw.dlg, &event);
 
    if (rc == FR_UNKNOWN)
      rc = menu_function_dispatcher(menu->win, &event);
    if (rc == FR_UNKNOWN)
      rc = global_function_dispatcher(menu->win, &event);
  } while (!sd.done);
 
  window_set_focus(old_focus);
  simple_dialog_free(&sdw.dlg);
  return sd.key;
}