functions.c

Go to the documentation of this file.

 
#include "config.h"
#include <stdbool.h>
#include <stdio.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "email/lib.h"
#include "core/lib.h"
#include "gui/lib.h"
#include "functions.h"
#include "key/lib.h"
#include "menu/lib.h"
#include "ncrypt/lib.h"
#include "question/lib.h"
#include "send/lib.h"
#include "attach.h"
#include "module_data.h"
#include "mutt_attach.h"
#include "private_data.h"
#include "recvattach.h"
#include "recvcmd.h"

static const char *Function_not_permitted_in_attach_message_mode = N_(
    "Function not permitted in attach-message mode");
 
// clang-format off
static const struct MenuFuncOp OpAttach[] = { /* map: attach */
  { "bounce-message",                OP_BOUNCE_MESSAGE },
  { "check-traditional-pgp",         OP_CHECK_TRADITIONAL },
  { "collapse-parts",                OP_ATTACH_COLLAPSE },
  { "compose-to-sender",             OP_COMPOSE_TO_SENDER },
  { "delete-entry",                  OP_ATTACH_DELETE },
  { "display-toggle-weed",           OP_DISPLAY_HEADERS },
  { "edit-type",                     OP_ATTACH_EDIT_TYPE },
  { "exit",                          OP_EXIT },
  { "extract-keys",                  OP_EXTRACT_KEYS },
  { "followup-message",              OP_FOLLOWUP },
  { "forget-passphrase",             OP_FORGET_PASSPHRASE },
  { "forward-message",               OP_FORWARD_MESSAGE },
  { "forward-to-group",              OP_FORWARD_TO_GROUP },
  { "group-chat-reply",              OP_GROUP_CHAT_REPLY },
  { "group-reply",                   OP_GROUP_REPLY },
  { "list-reply",                    OP_LIST_REPLY },
  { "list-subscribe",                OP_LIST_SUBSCRIBE },
  { "list-unsubscribe",              OP_LIST_UNSUBSCRIBE },
  { "pipe-entry",                    OP_PIPE },
  { "pipe-message",                  OP_PIPE },
  { "print-entry",                   OP_ATTACH_PRINT },
  { "reply",                         OP_REPLY },
  { "resend-message",                OP_RESEND },
  { "save-entry",                    OP_ATTACH_SAVE },
  { "undelete-entry",                OP_ATTACH_UNDELETE },
  { "view-attach",                   OP_ATTACH_VIEW },
  { "view-mailcap",                  OP_ATTACH_VIEW_MAILCAP },
  { "view-pager",                    OP_ATTACH_VIEW_PAGER },
  { "view-text",                     OP_ATTACH_VIEW_TEXT },
  { NULL, 0 },
};

static const struct MenuOpSeq AttachmentDefaultBindings[] = { /* map: attach */
  { OP_ATTACH_COLLAPSE,                "v" },
  { OP_ATTACH_DELETE,                  "d" },
  { OP_ATTACH_EDIT_TYPE,               "\005" },           // <Ctrl-E>
  { OP_EXIT,                               "q" },
  { OP_PIPE,                               "|" },
  { OP_ATTACH_PRINT,                   "p" },
  { OP_ATTACH_SAVE,                    "s" },
  { OP_ATTACH_UNDELETE,                "u" },
  { OP_ATTACH_VIEW,                    "<keypadenter>" },
  { OP_ATTACH_VIEW,                    "\n" },             // <Enter>
  { OP_ATTACH_VIEW,                    "\r" },             // <Return>
  { OP_ATTACH_VIEW_MAILCAP,            "m" },
  { OP_ATTACH_VIEW_TEXT,               "T" },
  { OP_BOUNCE_MESSAGE,                     "b" },
  { OP_CHECK_TRADITIONAL,                  "\033P" },          // <Alt-P>
  { OP_DISPLAY_HEADERS,                    "h" },
  { OP_EXTRACT_KEYS,                       "\013" },           // <Ctrl-K>
  { OP_FORGET_PASSPHRASE,                  "\006" },           // <Ctrl-F>
  { OP_FORWARD_MESSAGE,                    "f" },
  { OP_GROUP_REPLY,                        "g" },
  { OP_LIST_REPLY,                         "L" },
  { OP_REPLY,                              "r" },
  { OP_RESEND,                             "\033e" },          // <Alt-e>
  { 0, NULL },
};
// clang-format on

void attach_init_keys(struct NeoMutt *n, struct SubMenu *sm_generic)
{
  struct AttachModuleData *mod_data = neomutt_get_module_data(n, MODULE_ID_ATTACH);
  ASSERT(mod_data);
 
  struct MenuDefinition *md = NULL;
  struct SubMenu *sm = NULL;
 
  sm = km_register_submenu(OpAttach);
  md = km_register_menu(MENU_ATTACH, "attach");
  km_menu_add_submenu(md, sm);
  km_menu_add_submenu(md, sm_generic);
  km_menu_add_bindings(md, AttachmentDefaultBindings);
 
  mod_data->menu_attach = md;
}

static void attach_collapse(struct AttachCtx *actx, struct Menu *menu, struct ConfigSubset *sub)
{
  int rindex, curlevel;
 
  struct AttachPtr *cur_att = current_attachment(actx, menu);
  cur_att->collapsed = !cur_att->collapsed;
  /* When expanding, expand all the children too */
  if (cur_att->collapsed)
    return;
 
  curlevel = cur_att->level;
  const int index = menu_get_index(menu);
  rindex = actx->v2r[index] + 1;
 
  const bool c_digest_collapse = cs_subset_bool(sub, "digest_collapse");
  while ((rindex < actx->idxlen) && (actx->idx[rindex]->level > curlevel))
  {
    if (c_digest_collapse && (actx->idx[rindex]->body->type == TYPE_MULTIPART) &&
        mutt_istr_equal(actx->idx[rindex]->body->subtype, "digest"))
    {
      actx->idx[rindex]->collapsed = true;
    }
    else
    {
      actx->idx[rindex]->collapsed = false;
    }
    rindex++;
  }
}

static bool check_attach(struct AttachPrivateData *priv)
{
  if (priv->attach_msg)
  {
    mutt_flushinp();
    mutt_error("%s", _(Function_not_permitted_in_attach_message_mode));
    return true;
  }
 
  return false;
}

static bool check_readonly(struct Mailbox *m)
{
  if (!m || m->readonly)
  {
    mutt_flushinp();
    mutt_error(_("Mailbox is read-only"));
    return true;
  }
 
  return false;
}

static void recvattach_extract_pgp_keys(struct AttachPtrArray *aa)
{
  struct AttachPtr **app = NULL;
  ARRAY_FOREACH(app, aa)
  {
    crypt_pgp_extract_key_from_attachment((*app)->fp, (*app)->body);
  }
}

static int recvattach_pgp_check_traditional(struct AttachPtrArray *aa)
{
  int rc = 0;
 
  struct AttachPtr **app = NULL;
  ARRAY_FOREACH(app, aa)
  {
    rc = rc || crypt_pgp_check_traditional((*app)->fp, (*app)->body, true);
  }
 
  return rc;
}
 
// -----------------------------------------------------------------------------

static int op_attach_collapse(struct AttachFunctionData *fdata, const struct KeyEvent *event)
{
  struct AttachPrivateData *priv = fdata->priv;
  struct AttachPtr *cur_att = current_attachment(priv->actx, priv->menu);
  if (!cur_att->body->parts)
  {
    mutt_error(_("There are no subparts to show"));
    return FR_ERROR;
  }
  attach_collapse(priv->actx, priv->menu, fdata->n->sub);
  mutt_update_recvattach_menu(priv->actx, priv->menu, false);
  return FR_SUCCESS;
}

static void attach_apply_set_deleted(struct AttachPtrArray *apa, bool deleted,
                                     int *num_changed, int *num_blocked)
{
  int changed = 0;
  int blocked = 0;
 
  if (apa)
  {
    struct AttachPtr **app = NULL;
    ARRAY_FOREACH(app, apa)
    {
      struct AttachPtr *ap = *app;
      if (!ap || !ap->body)
        continue;
 
      if (deleted && (ap->parent_type != TYPE_MULTIPART))
      {
        blocked++;
        continue;
      }
 
      ap->body->deleted = deleted;
      changed++;
    }
  }
 
  if (num_changed)
    *num_changed = changed;
  if (num_blocked)
    *num_blocked = blocked;
}

static int op_attach_delete(struct AttachFunctionData *fdata, const struct KeyEvent *event)
{
  struct AttachPrivateData *priv = fdata->priv;
  if (check_readonly(priv->mailbox))
    return FR_ERROR;
 
  if (priv->mailbox->type == MUTT_POP)
  {
    mutt_flushinp();
    mutt_error(_("Can't delete attachment from POP server"));
    return FR_ERROR;
  }
 
  if (priv->mailbox->type == MUTT_NNTP)
  {
    mutt_flushinp();
    mutt_error(_("Can't delete attachment from news server"));
    return FR_ERROR;
  }
 
  if ((WithCrypto != 0) && (priv->actx->email->security & SEC_ENCRYPT))
  {
    mutt_message(_("Deletion of attachments from encrypted messages is unsupported"));
    return FR_ERROR;
  }
  if ((WithCrypto != 0) && (priv->actx->email->security & (SEC_SIGN | SEC_PARTSIGN)))
  {
    mutt_message(_("Deletion of attachments from signed messages may invalidate the signature"));
  }
 
  struct AttachPtrArray aa = ARRAY_HEAD_INITIALIZER;
  if (aa_add_selection(&aa, priv->actx, priv->menu, priv->menu->tag_prefix,
                       event->count) < 0)
  {
    ARRAY_FREE(&aa);
    return FR_ERROR;
  }
 
  if (ARRAY_EMPTY(&aa))
  {
    ARRAY_FREE(&aa);
    return FR_NO_ACTION;
  }
 
  int changed = 0;
  int blocked = 0;
  attach_apply_set_deleted(&aa, true, &changed, &blocked);
  const int num = ARRAY_SIZE(&aa);
  ARRAY_FREE(&aa);
 
  if (blocked > 0)
    mutt_message(_("Only deletion of multipart attachments is supported"));
 
  if (changed == 0)
    return blocked ? FR_ERROR : FR_NO_ACTION;
 
  if (priv->menu->tag_prefix)
  {
    menu_queue_redraw(priv->menu, MENU_REDRAW_INDEX);
  }
  else
  {
    const bool c_resolve = cs_subset_bool(fdata->n->sub, "resolve");
    const int next = menu_get_index(priv->menu) + num;
    if (c_resolve && (next < priv->menu->max))
    {
      menu_set_index(priv->menu, next);
    }
    else
    {
      menu_queue_redraw(priv->menu, (num > 1) ? MENU_REDRAW_INDEX : MENU_REDRAW_CURRENT);
    }
  }
 
  return FR_SUCCESS;
}

static int op_attach_edit_type(struct AttachFunctionData *fdata, const struct KeyEvent *event)
{
  struct AttachPrivateData *priv = fdata->priv;
  recvattach_edit_content_type(priv->actx, priv->menu, priv->actx->email);
  menu_queue_redraw(priv->menu, MENU_REDRAW_INDEX);
  return FR_SUCCESS;
}

static int op_attach_pipe(struct AttachFunctionData *fdata, const struct KeyEvent *event)
{
  struct AttachPrivateData *priv = fdata->priv;
  struct AttachPtrArray aa = ARRAY_HEAD_INITIALIZER;
  aa_add_selection(&aa, priv->actx, priv->menu, priv->menu->tag_prefix, event->count);
  mutt_pipe_attachment_list(&aa, false);
  ARRAY_FREE(&aa);
  return FR_SUCCESS;
}

static int op_attach_print(struct AttachFunctionData *fdata, const struct KeyEvent *event)
{
  struct AttachPrivateData *priv = fdata->priv;
  struct AttachPtrArray aa = ARRAY_HEAD_INITIALIZER;
  aa_add_selection(&aa, priv->actx, priv->menu, priv->menu->tag_prefix, event->count);
  mutt_print_attachment_list(&aa);
  ARRAY_FREE(&aa);
  return FR_SUCCESS;
}

static int op_attach_save(struct AttachFunctionData *fdata, const struct KeyEvent *event)
{
  struct AttachPrivateData *priv = fdata->priv;
  struct AttachPtrArray aa = ARRAY_HEAD_INITIALIZER;
  aa_add_selection(&aa, priv->actx, priv->menu, priv->menu->tag_prefix, event->count);
  mutt_save_attachment_list(&aa, priv->actx->email, priv->menu);
 
  const bool c_resolve = cs_subset_bool(fdata->n->sub, "resolve");
  const int index = menu_get_index(priv->menu) + 1;
  if ((ARRAY_SIZE(&aa) == 1) && c_resolve && (index < priv->menu->max))
    menu_set_index(priv->menu, index);
  ARRAY_FREE(&aa);
  return FR_SUCCESS;
}

static int op_attach_undelete(struct AttachFunctionData *fdata, const struct KeyEvent *event)
{
  struct AttachPrivateData *priv = fdata->priv;
  if (check_readonly(priv->mailbox))
    return FR_ERROR;
 
  struct AttachPtrArray aa = ARRAY_HEAD_INITIALIZER;
  if (aa_add_selection(&aa, priv->actx, priv->menu, priv->menu->tag_prefix,
                       event->count) < 0)
  {
    ARRAY_FREE(&aa);
    return FR_ERROR;
  }
 
  if (ARRAY_EMPTY(&aa))
  {
    ARRAY_FREE(&aa);
    return FR_NO_ACTION;
  }
 
  attach_apply_set_deleted(&aa, false, NULL, NULL);
  const int num = ARRAY_SIZE(&aa);
  ARRAY_FREE(&aa);
 
  if (priv->menu->tag_prefix)
  {
    menu_queue_redraw(priv->menu, MENU_REDRAW_INDEX);
  }
  else
  {
    const bool c_resolve = cs_subset_bool(fdata->n->sub, "resolve");
    const int next = menu_get_index(priv->menu) + num;
    if (c_resolve && (next < priv->menu->max))
    {
      menu_set_index(priv->menu, next);
    }
    else
    {
      menu_queue_redraw(priv->menu, (num > 1) ? MENU_REDRAW_INDEX : MENU_REDRAW_CURRENT);
    }
  }
 
  return FR_SUCCESS;
}

static int op_attach_view(struct AttachFunctionData *fdata, const struct KeyEvent *event)
{
  struct AttachPrivateData *priv = fdata->priv;
  priv->op = mutt_attach_display_loop(priv->sub, priv->menu, event->op,
                                      priv->actx->email, priv->actx, true);
  menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
 
  return FR_CONTINUE;
}

static int op_attach_view_mailcap(struct AttachFunctionData *fdata, const struct KeyEvent *event)
{
  struct AttachPrivateData *priv = fdata->priv;
  struct AttachPtr *cur_att = current_attachment(priv->actx, priv->menu);
  mutt_view_attachment(cur_att->fp, cur_att->body, MUTT_VA_MAILCAP,
                       priv->actx->email, priv->actx, priv->menu->win);
  menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
  return FR_SUCCESS;
}

static int op_attach_view_pager(struct AttachFunctionData *fdata, const struct KeyEvent *event)
{
  struct AttachPrivateData *priv = fdata->priv;
  struct AttachPtr *cur_att = current_attachment(priv->actx, priv->menu);
  mutt_view_attachment(cur_att->fp, cur_att->body, MUTT_VA_PAGER,
                       priv->actx->email, priv->actx, priv->menu->win);
  menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
  return FR_SUCCESS;
}

static int op_attach_view_text(struct AttachFunctionData *fdata, const struct KeyEvent *event)
{
  struct AttachPrivateData *priv = fdata->priv;
  struct AttachPtr *cur_att = current_attachment(priv->actx, priv->menu);
  mutt_view_attachment(cur_att->fp, cur_att->body, MUTT_VA_AS_TEXT,
                       priv->actx->email, priv->actx, priv->menu->win);
  menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
  return FR_SUCCESS;
}

static int op_bounce_message(struct AttachFunctionData *fdata, const struct KeyEvent *event)
{
  struct AttachPrivateData *priv = fdata->priv;
  if (check_attach(priv))
    return FR_ERROR;
  struct AttachPtrArray aa = ARRAY_HEAD_INITIALIZER;
  aa_add_selection(&aa, priv->actx, priv->menu, priv->menu->tag_prefix, event->count);
  attach_bounce_message(&aa, priv->mailbox);
  ARRAY_FREE(&aa);
  menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
  return FR_SUCCESS;
}

static int op_check_traditional(struct AttachFunctionData *fdata, const struct KeyEvent *event)
{
  struct AttachPrivateData *priv = fdata->priv;
  struct AttachPtrArray aa = ARRAY_HEAD_INITIALIZER;
  aa_add_selection(&aa, priv->actx, priv->menu, priv->menu->tag_prefix, event->count);
  if (((WithCrypto & APPLICATION_PGP) != 0) && recvattach_pgp_check_traditional(&aa))
  {
    priv->actx->email->security = crypt_query(NULL);
    menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
  }
  ARRAY_FREE(&aa);
  return FR_SUCCESS;
}

static int op_compose_to_sender(struct AttachFunctionData *fdata, const struct KeyEvent *event)
{
  struct AttachPrivateData *priv = fdata->priv;
  if (check_attach(priv))
    return FR_ERROR;
  struct AttachPtrArray aa = ARRAY_HEAD_INITIALIZER;
  aa_add_selection(&aa, priv->actx, priv->menu, priv->menu->tag_prefix, event->count);
  mutt_attach_mail_sender(&aa);
  ARRAY_FREE(&aa);
  menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
  return FR_SUCCESS;
}

static int op_exit(struct AttachFunctionData *fdata, const struct KeyEvent *event)
{
  struct AttachPrivateData *priv = fdata->priv;
  priv->actx->email->attach_del = false;
  for (int i = 0; i < priv->actx->idxlen; i++)
  {
    if (priv->actx->idx[i]->body && priv->actx->idx[i]->body->deleted)
    {
      priv->actx->email->attach_del = true;
      break;
    }
  }
  if (priv->actx->email->attach_del)
    priv->actx->email->changed = true;
 
  mutt_actx_free(&priv->actx);
  return FR_DONE;
}

static int op_extract_keys(struct AttachFunctionData *fdata, const struct KeyEvent *event)
{
  struct AttachPrivateData *priv = fdata->priv;
  if (!(WithCrypto & APPLICATION_PGP))
    return FR_NO_ACTION;
 
  struct AttachPtrArray aa = ARRAY_HEAD_INITIALIZER;
  aa_add_selection(&aa, priv->actx, priv->menu, priv->menu->tag_prefix, event->count);
  recvattach_extract_pgp_keys(&aa);
  ARRAY_FREE(&aa);
  menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
 
  return FR_SUCCESS;
}

static int op_forget_passphrase(struct AttachFunctionData *fdata, const struct KeyEvent *event)
{
  crypt_forget_passphrase();
  return FR_SUCCESS;
}

static int op_forward_message(struct AttachFunctionData *fdata, const struct KeyEvent *event)
{
  struct AttachPrivateData *priv = fdata->priv;
  if (check_attach(priv))
    return FR_ERROR;
  struct AttachPtrArray aa = ARRAY_HEAD_INITIALIZER;
  aa_add_selection(&aa, priv->actx, priv->menu, priv->menu->tag_prefix, event->count);
  mutt_attach_forward(&aa, priv->actx->email, priv->actx, SEND_NONE);
  ARRAY_FREE(&aa);
  menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
  return FR_SUCCESS;
}

static int op_list_subscribe(struct AttachFunctionData *fdata, const struct KeyEvent *event)
{
  struct AttachPrivateData *priv = fdata->priv;
  if (check_attach(priv))
    return FR_ERROR;
 
  return mutt_send_list_subscribe(priv->mailbox, priv->actx->email) ? FR_SUCCESS : FR_ERROR;
}

static int op_list_unsubscribe(struct AttachFunctionData *fdata, const struct KeyEvent *event)
{
  struct AttachPrivateData *priv = fdata->priv;
  if (check_attach(priv))
    return FR_ERROR;
 
  return mutt_send_list_unsubscribe(priv->mailbox, priv->actx->email) ? FR_SUCCESS : FR_ERROR;
}

static int op_reply(struct AttachFunctionData *fdata, const struct KeyEvent *event)
{
  struct AttachPrivateData *priv = fdata->priv;
  if (check_attach(priv))
    return FR_ERROR;
 
  const int op = event->op;
  SendFlags flags = SEND_REPLY;
  if (op == OP_GROUP_REPLY)
    flags |= SEND_GROUP_REPLY;
  else if (op == OP_GROUP_CHAT_REPLY)
    flags |= SEND_GROUP_CHAT_REPLY;
  else if (op == OP_LIST_REPLY)
    flags |= SEND_LIST_REPLY;
 
  struct AttachPtrArray aa = ARRAY_HEAD_INITIALIZER;
  aa_add_selection(&aa, priv->actx, priv->menu, priv->menu->tag_prefix, event->count);
  mutt_attach_reply(&aa, priv->mailbox, priv->actx->email, priv->actx, flags);
  ARRAY_FREE(&aa);
  menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
  return FR_SUCCESS;
}

static int op_resend(struct AttachFunctionData *fdata, const struct KeyEvent *event)
{
  struct AttachPrivateData *priv = fdata->priv;
  if (check_attach(priv))
    return FR_ERROR;
  struct AttachPtrArray aa = ARRAY_HEAD_INITIALIZER;
  aa_add_selection(&aa, priv->actx, priv->menu, priv->menu->tag_prefix, event->count);
  mutt_attach_resend(&aa, priv->mailbox);
  ARRAY_FREE(&aa);
  menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
  return FR_SUCCESS;
}
 
// -----------------------------------------------------------------------------

static int op_followup(struct AttachFunctionData *fdata, const struct KeyEvent *event)
{
  struct AttachPrivateData *priv = fdata->priv;
  if (check_attach(priv))
    return FR_ERROR;
 
  struct AttachPtr *cur_att = current_attachment(priv->actx, priv->menu);
  if (!cur_att->body->email || !cur_att->body->email->env)
  {
    mutt_error(_("You may only followup to message/rfc822 parts"));
    return FR_ERROR;
  }
  if (!cur_att->body->email->env->followup_to ||
      !mutt_istr_equal(cur_att->body->email->env->followup_to, "poster") ||
      (query_quadoption(_("Reply by mail as poster prefers?"), fdata->n->sub,
                        "followup_to_poster") != MUTT_YES))
  {
    struct AttachPtrArray aa = ARRAY_HEAD_INITIALIZER;
    aa_add_selection(&aa, priv->actx, priv->menu, priv->menu->tag_prefix, event->count);
    mutt_attach_reply(&aa, priv->mailbox, priv->actx->email, priv->actx, SEND_NEWS | SEND_REPLY);
    ARRAY_FREE(&aa);
    menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
    return FR_SUCCESS;
  }
 
  return op_reply(fdata, event);
}

static int op_forward_to_group(struct AttachFunctionData *fdata, const struct KeyEvent *event)
{
  struct AttachPrivateData *priv = fdata->priv;
  if (check_attach(priv))
    return FR_ERROR;
  struct AttachPtrArray aa = ARRAY_HEAD_INITIALIZER;
  aa_add_selection(&aa, priv->actx, priv->menu, priv->menu->tag_prefix, event->count);
  mutt_attach_forward(&aa, priv->actx->email, priv->actx, SEND_NEWS);
  ARRAY_FREE(&aa);
  menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
  return FR_SUCCESS;
}
 
// -----------------------------------------------------------------------------

static const struct AttachFunction AttachFunctions[] = {
  // clang-format off
  { OP_ATTACH_COLLAPSE,     op_attach_collapse     },
  { OP_ATTACH_DELETE,       op_attach_delete       },
  { OP_ATTACH_EDIT_TYPE,    op_attach_edit_type    },
  { OP_ATTACH_PRINT,        op_attach_print        },
  { OP_ATTACH_SAVE,         op_attach_save         },
  { OP_ATTACH_UNDELETE,     op_attach_undelete     },
  { OP_ATTACH_VIEW,         op_attach_view         },
  { OP_ATTACH_VIEW_MAILCAP, op_attach_view_mailcap },
  { OP_ATTACH_VIEW_PAGER,   op_attach_view_pager   },
  { OP_ATTACH_VIEW_TEXT,    op_attach_view_text    },
  { OP_BOUNCE_MESSAGE,      op_bounce_message      },
  { OP_CHECK_TRADITIONAL,   op_check_traditional   },
  { OP_COMPOSE_TO_SENDER,   op_compose_to_sender   },
  { OP_DISPLAY_HEADERS,     op_attach_view         },
  { OP_EXIT,                op_exit                },
  { OP_EXTRACT_KEYS,        op_extract_keys        },
  { OP_FOLLOWUP,            op_followup            },
  { OP_FORGET_PASSPHRASE,   op_forget_passphrase   },
  { OP_FORWARD_MESSAGE,     op_forward_message     },
  { OP_FORWARD_TO_GROUP,    op_forward_to_group    },
  { OP_GROUP_CHAT_REPLY,    op_reply               },
  { OP_GROUP_REPLY,         op_reply               },
  { OP_LIST_REPLY,          op_reply               },
  { OP_LIST_SUBSCRIBE,      op_list_subscribe      },
  { OP_LIST_UNSUBSCRIBE,    op_list_unsubscribe    },
  { OP_PIPE,                op_attach_pipe         },
  { OP_REPLY,               op_reply               },
  { OP_RESEND,              op_resend              },
  { 0, NULL },
  // clang-format on
};

int attach_function_dispatcher(struct MuttWindow *win, const struct KeyEvent *event)
{
  // The Dispatcher may be called on any Window in the Dialog
  struct MuttWindow *dlg = dialog_find(win);
  if (!event || !dlg || !dlg->wdata)
  {
    dispatcher_flush_on_error(FR_ERROR);
    return FR_ERROR;
  }
 
  struct Menu *menu = dlg->wdata;
  struct AttachPrivateData *priv = menu->mdata;
  if (!priv)
  {
    dispatcher_flush_on_error(FR_ERROR);
    return FR_ERROR;
  }
 
  const int op = event->op;
 
  struct AttachFunctionData fdata = {
    .n = NeoMutt,
    .priv = priv,
  };
 
  int rc = FR_UNKNOWN;
  for (size_t i = 0; AttachFunctions[i].op != OP_NULL; i++)
  {
    const struct AttachFunction *fn = &AttachFunctions[i];
    if (fn->op == op)
    {
      rc = fn->function(&fdata, event);
      break;
    }
  }
 
  dispatcher_flush_on_error(rc);
  return rc;
}