get.c

Go to the documentation of this file.

 
#include "config.h"
#include <ctype.h>
#include <limits.h>
#include <stdbool.h>
#include <string.h>
#include <unistd.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "core/lib.h"
#include "gui/lib.h"
#include "get.h"
#include "menu/lib.h"
#include "globals.h"
#include "keymap.h"
#include "menu.h"
#include "module_data.h"
#include "notify.h"
#ifdef USE_INOTIFY
#include "monitor.h"
#endif

static const int MaxKeyLoop = 64;

void mutt_push_macro_repeated(char *macro, int count)
{
  int repeat = (count > 0) ? count : 1;
 
  const short c_macro_repeat_max = cs_subset_number(NeoMutt->sub, "macro_repeat_max");
  if ((c_macro_repeat_max > 0) && (repeat > c_macro_repeat_max))
    repeat = c_macro_repeat_max;
 
  for (int i = 0; i < repeat; i++)
    generic_tokenize_push_string(macro);
}
 
// It's not possible to unget more than one char under some curses libs,
// so roll our own input buffering routines.


void mutt_flushinp(void)
{
  struct KeyModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_KEY);
  const size_t unget_count = ARRAY_SIZE(&mod_data->unget_key_events);
  const size_t macro_count = ARRAY_SIZE(&mod_data->macro_events);
  ARRAY_SHRINK(&mod_data->unget_key_events, ARRAY_SIZE(&mod_data->unget_key_events));
  ARRAY_SHRINK(&mod_data->macro_events, ARRAY_SIZE(&mod_data->macro_events));
 
  if ((unget_count + macro_count) > 0)
  {
    mutt_debug(LL_DEBUG1, "Flushed %zu queued key events (%zu unget, %zu macro)\n",
               unget_count + macro_count, unget_count, macro_count);
  }
  flushinp();
}

struct KeyEvent *array_pop(struct KeyEventArray *a)
{
  if (ARRAY_EMPTY(a))
  {
    return NULL;
  }
 
  struct KeyEvent *event = ARRAY_LAST(a);
  ARRAY_SHRINK(a, 1);
  return event;
}

void array_add(struct KeyEventArray *a, int ch, int op)
{
  struct KeyEvent event = { ch, op, 0 };
  ARRAY_ADD(a, event);
}

void array_to_endcond(struct KeyEventArray *a)
{
  while (!ARRAY_EMPTY(a))
  {
    if (array_pop(a)->op == OP_END_COND)
    {
      return;
    }
  }
}

void mutt_unget_ch(int ch)
{
  struct KeyModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_KEY);
  array_add(&mod_data->unget_key_events, ch, OP_NULL);
}

void mutt_unget_op(int op)
{
  struct KeyModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_KEY);
  array_add(&mod_data->unget_key_events, 0, op);
}

void mutt_push_macro_event(int ch, int op)
{
  struct KeyModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_KEY);
  array_add(&mod_data->macro_events, ch, op);
}

void mutt_flush_macro_to_endcond(void)
{
  struct KeyModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_KEY);
  array_to_endcond(&mod_data->macro_events);
}
 
#ifdef USE_INOTIFY
static int mutt_monitor_getch_timeout(int timeout_ms)
{
  /* ncurses has its own internal buffer, so before we perform a poll,
   * we need to make sure there isn't a character waiting */
  timeout(0);
  int ch = getch();
  timeout(timeout_ms);
  if (ch == ERR)
  {
    if (mutt_monitor_poll() != 0)
      ch = ERR;
    else
      ch = getch();
  }
  return ch;
}
#endif /* USE_INOTIFY */

static struct KeyEvent mutt_getch_timeout(GetChFlags flags, int timeout_ms)
{
  static const struct KeyEvent event_abort = { 0, OP_ABORT, 0 };
  static const struct KeyEvent event_repaint = { 0, OP_REPAINT, 0 };
  static const struct KeyEvent event_timeout = { 0, OP_TIMEOUT, 0 };
 
  if (!OptGui)
    return event_abort;
 
  struct KeyModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_KEY);
 
  struct KeyEvent *event_key = array_pop(&mod_data->unget_key_events);
  if (event_key)
    return *event_key;
 
  if (!(flags & GETCH_IGNORE_MACRO))
  {
    event_key = array_pop(&mod_data->macro_events);
    if (event_key)
      return *event_key;
  }
 
  int ch;
  SigInt = false;
  mutt_sig_allow_interrupt(true);
  timeout(timeout_ms);
#ifdef USE_INOTIFY
  ch = mutt_monitor_getch_timeout(timeout_ms);
#else
  ch = getch();
#endif
  mutt_sig_allow_interrupt(false);
 
  if (SigInt)
  {
    mutt_query_exit();
    return event_abort;
  }
 
  if (ch == KEY_RESIZE)
  {
    timeout(0);
    while ((ch = getch()) == KEY_RESIZE)
    {
      // do nothing
    }
  }
 
  if (ch == ERR)
  {
    if (!isatty(STDIN_FILENO)) // terminal was lost
      mutt_exit(1);
 
    if (SigWinch)
    {
      SigWinch = false;
      notify_send(NeoMutt->notify_resize, NT_RESIZE, 0, NULL);
      return event_repaint;
    }
 
    notify_send(NeoMutt->notify_timeout, NT_TIMEOUT, 0, NULL);
    return event_timeout;
  }
 
  if (ch == mod_data->abort_key)
    return event_abort;
 
  if (ch & 0x80)
  {
    const bool c_meta_key = cs_subset_bool(NeoMutt->sub, "meta_key");
    if (c_meta_key)
    {
      /* send ALT-x as ESC-x */
      ch &= ~0x80;
      mutt_unget_ch(ch);
      return (struct KeyEvent) { '\033', OP_NULL, 0 }; // Escape
    }
  }
 
  return (struct KeyEvent) { ch, OP_NULL, 0 };
}

struct KeyEvent mutt_getch(GetChFlags flags)
{
  return mutt_getch_timeout(flags, 1000);
}

void km_error_key(const struct MenuDefinition *md)
{
  if (!md)
    return;
 
  struct Keymap *key = km_find_func(md, OP_HELP);
  if (!key)
  {
    mutt_error(_("Key is not bound"));
    return;
  }
 
  struct Buffer *buf = buf_pool_get();
  keymap_expand_key(key, buf);
  mutt_error(_("Key is not bound.  Press '%s' for help."), buf_string(buf));
  buf_pool_release(&buf);
}

void generic_tokenize_push_string(char *s)
{
  struct KeyModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_KEY);
  char *pp = NULL;
  char *p = s + mutt_str_len(s) - 1;
  size_t l;
  int i, op = OP_NULL;
 
  while (p >= s)
  {
    /* if we see something like "<PageUp>", look to see if it is a real
     * function name and return the corresponding value */
    if (*p == '>')
    {
      for (pp = p - 1; pp >= s && *pp != '<'; pp--)
        ; // do nothing
 
      if (pp >= s)
      {
        i = parse_fkey(pp);
        if (i > 0)
        {
          mutt_push_macro_event(KEY_F(i), 0);
          p = pp - 1;
          continue;
        }
 
        l = p - pp + 1;
        for (i = 0; mod_data->key_names[i].name; i++)
        {
          if (mutt_istrn_equal(pp, mod_data->key_names[i].name, l))
            break;
        }
        if (mod_data->key_names[i].name)
        {
          /* found a match */
          mutt_push_macro_event(mod_data->key_names[i].value, 0);
          p = pp - 1;
          continue;
        }
 
        /* See if it is a valid command
         * skip the '<' and the '>' when comparing */
        struct Buffer *buf = buf_pool_get();
        buf_strcpy_n(buf, pp + 1, l - 2);
 
        for (enum MenuType j = 0; j < MENU_MAX; j++)
        {
          op = km_get_op_menu(j, buf_string(buf));
          if (op != OP_NULL)
            break;
        }
 
        buf_pool_release(&buf);
 
        if (op != OP_NULL)
        {
          mutt_push_macro_event(0, op);
          p = pp - 1;
          continue;
        }
      }
    }
    mutt_push_macro_event((unsigned char) *p--, 0); /* independent 8 bits chars */
  }
}

KeyGatherFlags gather_functions(const struct MenuDefinition *md, const keycode_t *keys,
                                int key_len, struct KeymapMatchArray *kma)
{
  if (!md || !keys || !kma)
    return 0;
 
  struct SubMenu **smp = NULL;
  KeyGatherFlags flags = KEY_GATHER_NO_MATCH;
 
  ARRAY_FOREACH(smp, &md->submenus)
  {
    struct Keymap *km = NULL;
 
    STAILQ_FOREACH(km, &(*smp)->keymaps, entries)
    {
      if (key_len > km->len)
        continue;
 
      bool match = true;
 
      for (int i = 0; i < key_len; i++)
      {
        if (keys[i] != km->keys[i])
        {
          match = false;
          break;
        }
      }
 
      if (match)
      {
        KeyGatherFlags fmatch = KEY_GATHER_NO_MATCH;
        if (km->len == key_len)
          fmatch = KEY_GATHER_MATCH;
        else
          fmatch = KEY_GATHER_LONGER;
 
        flags |= fmatch;
 
        struct KeymapMatch kmatch = { md->id, fmatch, km };
        ARRAY_ADD(kma, kmatch);
      }
    }
  }
 
  return flags;
}

enum DokeyState
{
  DKS_START = 1, 
  DKS_COUNTER,   
  DKS_NEED_MORE, 
};

static void key_progress_notify(const struct MenuDefinition *md, int count,
                                const keycode_t *keys, int key_len, GetChFlags flags)
{
  if (flags & GETCH_NO_FEEDBACK)
    return;
 
  struct EventKeyProgress ev_k = { 0 };
  ev_k.md = md;
  ev_k.count = count;
  ev_k.key_len = MAX(0, MIN(key_len, KEY_SEQ_MAX_LEN));
 
  for (int i = 0; i < ev_k.key_len; i++)
  {
    ev_k.keys[i] = keys[i];
  }
 
  notify_send(NeoMutt->notify, NT_KEY, NT_KEY_PROGRESS, &ev_k);
}

struct KeyEvent km_dokey(const struct MenuDefinition *md, GetChFlags flags)
{
  struct KeyEvent event = { 0, OP_NULL, 0 };
  enum DokeyState state = DKS_START;
  int count = 0;
  int count_digits = 0;
  int key_len = 0;
  struct Keymap *pending_exact = NULL;
  bool feedback_active = false;
  keycode_t keys[KEY_SEQ_MAX_LEN] = { 0 };
 
  const short c_key_timeout_idle = cs_subset_number(NeoMutt->sub, "key_timeout_idle");
  const short c_key_timeout_progress = cs_subset_number(NeoMutt->sub, "key_timeout_partial");
 
  if (!md)
    return event;
 
  for (int n = 0; n < MaxKeyLoop; n++)
  {
    const int timeout_ms = (state == DKS_START) ? c_key_timeout_idle : c_key_timeout_progress;
    event = mutt_getch_timeout(flags, timeout_ms);
 
    // abort, timeout, repaint
    if (event.op < OP_NULL)
    {
      if (event.op == OP_TIMEOUT)
      {
        if ((state == DKS_NEED_MORE) && pending_exact)
        {
          if (pending_exact->op != OP_MACRO)
          {
            key_progress_notify(md, count, keys, key_len, flags);
            key_progress_notify(md, 0, NULL, 0, flags);
            return (struct KeyEvent) { 0, pending_exact->op, count };
          }
 
          if (flags & GETCH_IGNORE_MACRO)
          {
            key_progress_notify(md, 0, NULL, 0, flags);
            return (struct KeyEvent) { 0, OP_NULL, 0 };
          }
 
          mutt_push_macro_repeated(pending_exact->macro, count_digits > 0 ? count : 0);
          state = DKS_START;
          count = 0;
          count_digits = 0;
          key_len = 0;
          pending_exact = NULL;
          memset(keys, 0, sizeof(keys));
          feedback_active = false;
          key_progress_notify(md, 0, NULL, 0, flags);
          continue;
        }
      }
 
      if (feedback_active || (state != DKS_START))
      {
        key_progress_notify(md, 0, NULL, 0, flags);
      }
      mutt_debug(LL_DEBUG3, "KEY: getch() %s\n", opcodes_get_name(event.op));
      return event;
    }
 
    // macro op pushed into queue (e.g. from `exec`)
    if (event.op > OP_NULL)
    {
      if (feedback_active || (state != DKS_START))
      {
        key_progress_notify(md, 0, NULL, 0, flags);
      }
      // Apply any count digits that arrived ahead of this op
      // (e.g. "5<next-entry>" inside a macro body),
      // preserving an explicit count already attached to the event.
      if ((event.count == 0) && (count_digits > 0))
        event.count = count;
      return event;
    }
 
    mutt_debug(LL_DEBUG3, "KEY: getch() '%c'\n", isprint(event.ch) ? event.ch : '?');
 
    // Check if digit keys have explicit bindings before using them as a counter
    if (!(flags & GETCH_NO_COUNTER) && (state != DKS_NEED_MORE) &&
        (event.ch >= '0') && (event.ch <= '9'))
    {
      keycode_t digit_key = event.ch;
      struct KeymapMatchArray digit_kma = ARRAY_HEAD_INITIALIZER;
      KeyGatherFlags digit_kgf = gather_functions(md, &digit_key, 1, &digit_kma);
      bool digit_bound = (digit_kgf & KEY_GATHER_MATCH);
      ARRAY_FREE(&digit_kma);
 
      if (!digit_bound)
      {
        if (count_digits >= KEY_COUNT_MAX_DIGITS)
        {
          key_progress_notify(md, count, keys, key_len, flags);
          key_progress_notify(md, 0, NULL, 0, flags);
          return (struct KeyEvent) { event.ch, OP_NULL, 0 };
        }
 
        const int digit = event.ch - '0';
        if ((count > (INT_MAX / 10)) ||
            ((count == (INT_MAX / 10)) && (digit > (INT_MAX % 10))))
        {
          key_progress_notify(md, count, keys, key_len, flags);
          key_progress_notify(md, 0, NULL, 0, flags);
          return (struct KeyEvent) { event.ch, OP_NULL, 0 };
        }
 
        count = (count * 10) + digit;
        count_digits++;
        state = DKS_COUNTER;
        feedback_active = true;
        key_progress_notify(md, count, keys, key_len, flags);
        continue;
      }
    }
 
    if (key_len >= KEY_SEQ_MAX_LEN)
    {
      key_progress_notify(md, count, keys, key_len, flags);
      key_progress_notify(md, 0, NULL, 0, flags);
      return (struct KeyEvent) { event.ch, OP_NULL, 0 };
    }
 
    keys[key_len] = event.ch;
    key_len++;
 
    struct KeymapMatchArray kma = ARRAY_HEAD_INITIALIZER;
    KeyGatherFlags kgf = gather_functions(md, keys, key_len, &kma);
 
    mutt_debug(LL_DEBUG3, "KEY: flags = %x\n", kgf);
 
    bool has_exact = false;
    bool has_longer = false;
    pending_exact = NULL;
 
    struct KeymapMatch *kmatch = NULL;
    ARRAY_FOREACH(kmatch, &kma)
    {
      if (kmatch->flags == KEY_GATHER_MATCH)
      {
        has_exact = true;
        if (!pending_exact)
          pending_exact = kmatch->keymap;
      }
      else if (kmatch->flags == KEY_GATHER_LONGER)
      {
        has_longer = true;
      }
    }
 
    if (!has_exact && !has_longer)
    {
      key_progress_notify(md, count, keys, key_len, flags);
      key_progress_notify(md, 0, NULL, 0, flags);
      mutt_debug(LL_DEBUG3, "KEY: FAIL1: ('%c', %s)\n",
                 isprint(event.ch) ? event.ch : '?', opcodes_get_name(event.op));
      ARRAY_FREE(&kma);
      return event;
    }
 
    if (has_exact && has_longer)
    {
      state = DKS_NEED_MORE;
      feedback_active = true;
      key_progress_notify(md, count, keys, key_len, flags);
      ARRAY_FREE(&kma);
      continue;
    }
 
    if (!has_exact && has_longer)
    {
      state = DKS_NEED_MORE;
      feedback_active = true;
      key_progress_notify(md, count, keys, key_len, flags);
      ARRAY_FREE(&kma);
      continue;
    }
 
    if (has_exact && pending_exact)
    {
      struct Keymap *map = pending_exact;
 
      if (map->op != OP_MACRO)
      {
        key_progress_notify(md, count, keys, key_len, flags);
        key_progress_notify(md, 0, NULL, 0, flags);
        mutt_debug(LL_DEBUG3, "KEY: SUCCESS: ('%c', %s)\n",
                   isprint(event.ch) ? event.ch : '?', opcodes_get_name(map->op));
        ARRAY_FREE(&kma);
        return (struct KeyEvent) { event.ch, map->op, count_digits > 0 ? count : 0 };
      }
 
      /* #GETCH_IGNORE_MACRO turns off processing the MacroEvents buffer
       * in mutt_getch().  Generating new macro events during that time would
       * result in undesired behavior once the option is turned off.
       *
       * Originally this returned -1, however that results in an unbuffered
       * username or password prompt being aborted.  Returning OP_NULL allows
       * mw_get_field() to display the keybinding pressed instead.
       *
       * It may be unexpected for a macro's keybinding to be returned,
       * but less so than aborting the prompt.  */
      if (flags & GETCH_IGNORE_MACRO)
      {
        key_progress_notify(md, 0, NULL, 0, flags);
        ARRAY_FREE(&kma);
        return (struct KeyEvent) { event.ch, OP_NULL, 0 };
      }
 
      mutt_push_macro_repeated(map->macro, count_digits > 0 ? count : 0);
      state = DKS_START;
      count = 0;
      count_digits = 0;
      key_len = 0;
      pending_exact = NULL;
      memset(keys, 0, sizeof(keys));
      feedback_active = false;
      key_progress_notify(md, 0, NULL, 0, flags);
      ARRAY_FREE(&kma);
      continue;
    }
 
    ARRAY_FREE(&kma);
  }
 
  key_progress_notify(md, 0, NULL, 0, flags);
  mutt_flushinp();
  mutt_error(_("Macro loop detected"));
  return (struct KeyEvent) { '\0', OP_ABORT, 0 };
}