functions.c File Reference

Attachment functions. More...

#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 "mutt_attach.h"
#include "private_data.h"
#include "recvattach.h"
#include "recvcmd.h"

Include dependency graph for functions.c:

Go to the source code of this file.

Functions
void	attach_init_keys (struct SubMenu *sm_generic)
	Initialise the Attach Keybindings - Implements ::init_keys_api.
static void	attach_collapse (struct AttachCtx *actx, struct Menu *menu)
	Close the tree of the current attachment.
static bool	check_attach (struct AttachPrivateData *priv)
	Check if in attach-message mode.
static bool	check_readonly (struct Mailbox *m)
	Check if the Mailbox is readonly.
static void	recvattach_extract_pgp_keys (struct AttachCtx *actx, struct Menu *menu)
	Extract PGP keys from attachments.
static int	recvattach_pgp_check_traditional (struct AttachCtx *actx, struct Menu *menu)
	Is the Attachment inline PGP?
static int	op_attachment_collapse (struct AttachPrivateData *priv, const struct KeyEvent *event)
	toggle display of subparts - Implements attach_function_t -
static int	op_attachment_delete (struct AttachPrivateData *priv, const struct KeyEvent *event)
	delete the current entry - Implements attach_function_t -
static int	op_attachment_edit_type (struct AttachPrivateData *priv, const struct KeyEvent *event)
	edit attachment content type - Implements attach_function_t -
static int	op_attachment_pipe (struct AttachPrivateData *priv, const struct KeyEvent *event)
	pipe message/attachment to a shell command - Implements attach_function_t -
static int	op_attachment_print (struct AttachPrivateData *priv, const struct KeyEvent *event)
	print the current entry - Implements attach_function_t -
static int	op_attachment_save (struct AttachPrivateData *priv, const struct KeyEvent *event)
	save message/attachment to a mailbox/file - Implements attach_function_t -
static int	op_attachment_undelete (struct AttachPrivateData *priv, const struct KeyEvent *event)
	undelete the current entry - Implements attach_function_t -
static int	op_attachment_view (struct AttachPrivateData *priv, const struct KeyEvent *event)
	view attachment using mailcap entry if necessary - Implements attach_function_t -
static int	op_attachment_view_mailcap (struct AttachPrivateData *priv, const struct KeyEvent *event)
	force viewing of attachment using mailcap - Implements attach_function_t -
static int	op_attachment_view_pager (struct AttachPrivateData *priv, const struct KeyEvent *event)
	view attachment in pager using copiousoutput mailcap - Implements attach_function_t -
static int	op_attachment_view_text (struct AttachPrivateData *priv, const struct KeyEvent *event)
	view attachment as text - Implements attach_function_t -
static int	op_bounce_message (struct AttachPrivateData *priv, const struct KeyEvent *event)
	remail a message to another user - Implements attach_function_t -
static int	op_check_traditional (struct AttachPrivateData *priv, const struct KeyEvent *event)
	check for classic PGP - Implements attach_function_t -
static int	op_compose_to_sender (struct AttachPrivateData *priv, const struct KeyEvent *event)
	compose new message to the current message sender - Implements attach_function_t -
static int	op_exit (struct AttachPrivateData *priv, const struct KeyEvent *event)
	exit this menu - Implements attach_function_t -
static int	op_extract_keys (struct AttachPrivateData *priv, const struct KeyEvent *event)
	extract supported public keys - Implements attach_function_t -
static int	op_forget_passphrase (struct AttachPrivateData *priv, const struct KeyEvent *event)
	wipe passphrases from memory - Implements attach_function_t -
static int	op_forward_message (struct AttachPrivateData *priv, const struct KeyEvent *event)
	forward a message with comments - Implements attach_function_t -
static int	op_list_subscribe (struct AttachPrivateData *priv, const struct KeyEvent *event)
	subscribe to a mailing list - Implements attach_function_t -
static int	op_list_unsubscribe (struct AttachPrivateData *priv, const struct KeyEvent *event)
	unsubscribe from a mailing list - Implements attach_function_t -
static int	op_reply (struct AttachPrivateData *priv, const struct KeyEvent *event)
	reply to a message - Implements attach_function_t -
static int	op_resend (struct AttachPrivateData *priv, const struct KeyEvent *event)
	use the current message as a template for a new one - Implements attach_function_t -
static int	op_followup (struct AttachPrivateData *priv, const struct KeyEvent *event)
	followup to newsgroup - Implements attach_function_t -
static int	op_forward_to_group (struct AttachPrivateData *priv, const struct KeyEvent *event)
	forward to newsgroup - Implements attach_function_t -
int	attach_function_dispatcher (struct MuttWindow *win, const struct KeyEvent *event)
	Perform a Attach function - Implements function_dispatcher_t -.

Variables
static const char *	Function_not_permitted_in_attach_message_mode
	Error message for unavailable functions in attach mode.
struct MenuDefinition *	MdAttach = NULL
	Attach Menu Definition.
static const struct MenuFuncOp	OpAttachment []
	Functions for the Attachment Menu.
static const struct MenuOpSeq	AttachmentDefaultBindings []
	Key bindings for the Attachment Menu.
static const struct AttachFunction	AttachFunctions []
	All the NeoMutt functions that the Attach supports.

Detailed Description

Attachment functions.

Authors

• Richard Russon
• Dennis Schön

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

Function Documentation

attach_init_keys()

void attach_init_keys

(

struct SubMenu *

sm_generic

)

Initialise the Attach Keybindings - Implements ::init_keys_api.

Definition at line 128 of file functions.c.

{
  struct MenuDefinition *md = NULL;
  struct SubMenu *sm = NULL;
 
  sm = km_register_submenu(OpAttachment);
  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);
 
  MdAttach = md;
}

Here is the call graph for this function:

Here is the caller graph for this function:

attach_collapse()

static void attach_collapse ( struct AttachCtx * actx, struct Menu * menu )

static

Close the tree of the current attachment.

Parameters

actx	Attachment context
menu	Menu listing Attachments

Definition at line 147 of file functions.c.

{
  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(NeoMutt->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++;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

check_attach()

static bool check_attach ( struct AttachPrivateData * priv )

static

Check if in attach-message mode.

Parameters

priv	Private Attach data

Return values

true	Mailbox is readonly

Definition at line 182 of file functions.c.

{
  if (priv->attach_msg)
  {
    mutt_flushinp();
    mutt_error("%s", _(Function_not_permitted_in_attach_message_mode));
    return true;
  }
 
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

check_readonly()

static bool check_readonly ( struct Mailbox * m )

static

Check if the Mailbox is readonly.

Parameters

m

Mailbox

Return values

true	Mailbox is readonly

Definition at line 199 of file functions.c.

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

Here is the call graph for this function:

Here is the caller graph for this function:

recvattach_extract_pgp_keys()

static void recvattach_extract_pgp_keys ( struct AttachCtx * actx, struct Menu * menu )

static

Extract PGP keys from attachments.

Parameters

actx	Attachment context
menu	Menu listing attachments

Definition at line 216 of file functions.c.

{
  if (menu->tag_prefix)
  {
    for (int i = 0; i < actx->idxlen; i++)
    {
      if (actx->idx[i]->body->tagged)
      {
        crypt_pgp_extract_key_from_attachment(actx->idx[i]->fp, actx->idx[i]->body);
      }
    }
  }
  else
  {
    struct AttachPtr *cur_att = current_attachment(actx, menu);
    crypt_pgp_extract_key_from_attachment(cur_att->fp, cur_att->body);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

recvattach_pgp_check_traditional()

static int recvattach_pgp_check_traditional ( struct AttachCtx * actx, struct Menu * menu )

static

Is the Attachment inline PGP?

Parameters

actx	Attachment to check
menu	Menu listing Attachments

Return values

1	The (tagged) Attachment(s) are inline PGP

Note

If the menu->tagprefix is set, all the tagged attachments will be checked.

Definition at line 243 of file functions.c.

{
  int rc = 0;
 
  if (menu->tag_prefix)
  {
    for (int i = 0; i < actx->idxlen; i++)
      if (actx->idx[i]->body->tagged)
        rc = rc || crypt_pgp_check_traditional(actx->idx[i]->fp, actx->idx[i]->body, true);
  }
  else
  {
    struct AttachPtr *cur_att = current_attachment(actx, menu);
    rc = crypt_pgp_check_traditional(cur_att->fp, cur_att->body, true);
  }
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

Function_not_permitted_in_attach_message_mode

const char* Function_not_permitted_in_attach_message_mode

static

Initial value:

= N_(
    "Function not permitted in attach-message mode")

Error message for unavailable functions in attach mode.

Definition at line 51 of file functions.c.

MdAttach

struct MenuDefinition* MdAttach = NULL

Attach Menu Definition.

Definition at line 55 of file functions.c.

OpAttachment

const struct MenuFuncOp OpAttachment[]

static

Functions for the Attachment Menu.

Definition at line 61 of file functions.c.

                                                { /* map: attachment */
  { "bounce-message",                OP_BOUNCE_MESSAGE },
  { "check-traditional-pgp",         OP_CHECK_TRADITIONAL },
  { "collapse-parts",                OP_ATTACHMENT_COLLAPSE },
  { "compose-to-sender",             OP_COMPOSE_TO_SENDER },
  { "delete-entry",                  OP_ATTACHMENT_DELETE },
  { "display-toggle-weed",           OP_DISPLAY_HEADERS },
  { "edit-type",                     OP_ATTACHMENT_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_ATTACHMENT_PRINT },
  { "reply",                         OP_REPLY },
  { "resend-message",                OP_RESEND },
  { "save-entry",                    OP_ATTACHMENT_SAVE },
  { "undelete-entry",                OP_ATTACHMENT_UNDELETE },
  { "view-attach",                   OP_ATTACHMENT_VIEW },
  { "view-mailcap",                  OP_ATTACHMENT_VIEW_MAILCAP },
  { "view-pager",                    OP_ATTACHMENT_VIEW_PAGER },
  { "view-text",                     OP_ATTACHMENT_VIEW_TEXT },
  { NULL, 0 },
};

AttachmentDefaultBindings

const struct MenuOpSeq AttachmentDefaultBindings[]

static

Initial value:

= { 
  { OP_ATTACHMENT_COLLAPSE,                "v" },
  { OP_ATTACHMENT_DELETE,                  "d" },
  { OP_ATTACHMENT_EDIT_TYPE,               "\005" },           
  { OP_EXIT,                               "q" },
  { OP_PIPE,                               "|" },
  { OP_ATTACHMENT_PRINT,                   "p" },
  { OP_ATTACHMENT_SAVE,                    "s" },
  { OP_ATTACHMENT_UNDELETE,                "u" },
  { OP_ATTACHMENT_VIEW,                    "<keypadenter>" },
  { OP_ATTACHMENT_VIEW,                    "\n" },             
  { OP_ATTACHMENT_VIEW,                    "\r" },             
  { OP_ATTACHMENT_VIEW_MAILCAP,            "m" },
  { OP_ATTACHMENT_VIEW_TEXT,               "T" },
  { OP_BOUNCE_MESSAGE,                     "b" },
  { OP_CHECK_TRADITIONAL,                  "\033P" },          
  { OP_DISPLAY_HEADERS,                    "h" },
  { OP_EXTRACT_KEYS,                       "\013" },           
  { OP_FORGET_PASSPHRASE,                  "\006" },           
  { OP_FORWARD_MESSAGE,                    "f" },
  { OP_GROUP_REPLY,                        "g" },
  { OP_LIST_REPLY,                         "L" },
  { OP_REPLY,                              "r" },
  { OP_RESEND,                             "\033e" },          
  { 0, NULL },
}

Key bindings for the Attachment Menu.

Definition at line 97 of file functions.c.

                                                            { /* map: attachment */
  { OP_ATTACHMENT_COLLAPSE,                "v" },
  { OP_ATTACHMENT_DELETE,                  "d" },
  { OP_ATTACHMENT_EDIT_TYPE,               "\005" },           // <Ctrl-E>
  { OP_EXIT,                               "q" },
  { OP_PIPE,                               "|" },
  { OP_ATTACHMENT_PRINT,                   "p" },
  { OP_ATTACHMENT_SAVE,                    "s" },
  { OP_ATTACHMENT_UNDELETE,                "u" },
  { OP_ATTACHMENT_VIEW,                    "<keypadenter>" },
  { OP_ATTACHMENT_VIEW,                    "\n" },             // <Enter>
  { OP_ATTACHMENT_VIEW,                    "\r" },             // <Return>
  { OP_ATTACHMENT_VIEW_MAILCAP,            "m" },
  { OP_ATTACHMENT_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 },
};

AttachFunctions

const struct AttachFunction AttachFunctions[]

static

All the NeoMutt functions that the Attach supports.

Definition at line 697 of file functions.c.

                                                       {
  // clang-format off
  { OP_ATTACHMENT_COLLAPSE,         op_attachment_collapse },
  { OP_ATTACHMENT_DELETE,           op_attachment_delete },
  { OP_ATTACHMENT_EDIT_TYPE,        op_attachment_edit_type },
  { OP_PIPE,                        op_attachment_pipe },
  { OP_ATTACHMENT_PRINT,            op_attachment_print },
  { OP_ATTACHMENT_SAVE,             op_attachment_save },
  { OP_ATTACHMENT_UNDELETE,         op_attachment_undelete },
  { OP_ATTACHMENT_VIEW,             op_attachment_view },
  { OP_ATTACHMENT_VIEW_MAILCAP,     op_attachment_view_mailcap },
  { OP_ATTACHMENT_VIEW_PAGER,       op_attachment_view_pager },
  { OP_ATTACHMENT_VIEW_TEXT,        op_attachment_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_attachment_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_REPLY,                       op_reply },
  { OP_RESEND,                      op_resend },
  { 0, NULL },
  // clang-format on
};