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 "module_data.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 NeoMutt *n, struct SubMenu *sm_generic)
	Initialise the Attach Keybindings - Implements ::init_keys_api.
static void	attach_collapse (struct AttachCtx *actx, struct Menu *menu, struct ConfigSubset *sub)
	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 AttachPtrArray *aa)
	Extract PGP keys from attachments.
static int	recvattach_pgp_check_traditional (struct AttachPtrArray *aa)
	Is the Attachment inline PGP?
static int	op_attach_collapse (struct AttachFunctionData *fdata, const struct KeyEvent *event)
	toggle display of subparts - Implements attach_function_t -
static void	attach_apply_set_deleted (struct AttachPtrArray *apa, bool deleted, int *num_changed, int *num_blocked)
	Apply the deleted flag to a working set of attachments.
static int	op_attach_delete (struct AttachFunctionData *fdata, const struct KeyEvent *event)
	delete the current entry - Implements attach_function_t -
static int	op_attach_edit_type (struct AttachFunctionData *fdata, const struct KeyEvent *event)
	edit attachment content type - Implements attach_function_t -
static int	op_attach_pipe (struct AttachFunctionData *fdata, const struct KeyEvent *event)
	pipe message/attachment to a shell command - Implements attach_function_t -
static int	op_attach_print (struct AttachFunctionData *fdata, const struct KeyEvent *event)
	print the current entry - Implements attach_function_t -
static int	op_attach_save (struct AttachFunctionData *fdata, const struct KeyEvent *event)
	save message/attachment to a mailbox/file - Implements attach_function_t -
static int	op_attach_undelete (struct AttachFunctionData *fdata, const struct KeyEvent *event)
	undelete the current entry - Implements attach_function_t -
static int	op_attach_view (struct AttachFunctionData *fdata, const struct KeyEvent *event)
	view attachment using mailcap entry if necessary - Implements attach_function_t -
static int	op_attach_view_mailcap (struct AttachFunctionData *fdata, const struct KeyEvent *event)
	force viewing of attachment using mailcap - Implements attach_function_t -
static int	op_attach_view_pager (struct AttachFunctionData *fdata, const struct KeyEvent *event)
	view attachment in pager using copiousoutput mailcap - Implements attach_function_t -
static int	op_attach_view_text (struct AttachFunctionData *fdata, const struct KeyEvent *event)
	view attachment as text - Implements attach_function_t -
static int	op_bounce_message (struct AttachFunctionData *fdata, const struct KeyEvent *event)
	remail a message to another user - Implements attach_function_t -
static int	op_check_traditional (struct AttachFunctionData *fdata, const struct KeyEvent *event)
	check for classic PGP - Implements attach_function_t -
static int	op_compose_to_sender (struct AttachFunctionData *fdata, const struct KeyEvent *event)
	compose new message to the current message sender - Implements attach_function_t -
static int	op_exit (struct AttachFunctionData *fdata, const struct KeyEvent *event)
	exit this menu - Implements attach_function_t -
static int	op_extract_keys (struct AttachFunctionData *fdata, const struct KeyEvent *event)
	extract supported public keys - Implements attach_function_t -
static int	op_forget_passphrase (struct AttachFunctionData *fdata, const struct KeyEvent *event)
	wipe passphrases from memory - Implements attach_function_t -
static int	op_forward_message (struct AttachFunctionData *fdata, const struct KeyEvent *event)
	forward a message with comments - Implements attach_function_t -
static int	op_list_subscribe (struct AttachFunctionData *fdata, const struct KeyEvent *event)
	subscribe to a mailing list - Implements attach_function_t -
static int	op_list_unsubscribe (struct AttachFunctionData *fdata, const struct KeyEvent *event)
	unsubscribe from a mailing list - Implements attach_function_t -
static int	op_reply (struct AttachFunctionData *fdata, const struct KeyEvent *event)
	reply to a message - Implements attach_function_t -
static int	op_resend (struct AttachFunctionData *fdata, const struct KeyEvent *event)
	use the current message as a template for a new one - Implements attach_function_t -
static int	op_followup (struct AttachFunctionData *fdata, const struct KeyEvent *event)
	followup to newsgroup - Implements attach_function_t -
static int	op_forward_to_group (struct AttachFunctionData *fdata, 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.
static const struct MenuFuncOp	OpAttach []
	Functions for the Attach 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 NeoMutt *	n,
		struct SubMenu *	sm_generic )

Initialise the Attach Keybindings - Implements ::init_keys_api.

Definition at line 126 of file functions.c.

{
  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;
}

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, struct ConfigSubset * sub )

static

Close the tree of the current attachment.

Parameters

actx	Attachment context
menu	Menu listing Attachments
sub	Config subset

Definition at line 149 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(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 184 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 201 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 AttachPtrArray * aa )

static

Extract PGP keys from attachments.

Parameters

aa	Selected attachments

Definition at line 217 of file functions.c.

{
  struct AttachPtr **app = NULL;
  ARRAY_FOREACH(app, aa)
  {
    crypt_pgp_extract_key_from_attachment((*app)->fp, (*app)->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 AttachPtrArray * aa )

static

Is the Attachment inline PGP?

Parameters

aa	Selected attachments

Return values

1	Any selected Attachment is inline PGP

Definition at line 231 of file functions.c.

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

Here is the call graph for this function:

Here is the caller graph for this function:

attach_apply_set_deleted()

static void attach_apply_set_deleted ( struct AttachPtrArray * apa, bool deleted, int * num_changed, int * num_blocked )

static

Apply the deleted flag to a working set of attachments.

Parameters

[in]	apa	Working set of AttachPtr pointers
[in]	deleted	true to mark as deleted, false to undelete
[out]	num_changed	Number of attachments actually changed
[out]	num_blocked	Number of attachments rejected (non-multipart)

Only multipart attachments may be deleted. Non-multipart attachments in the working set are skipped and counted in num_blocked.

Definition at line 273 of file functions.c.

{
  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;
}

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 52 of file functions.c.

OpAttach

const struct MenuFuncOp OpAttach[]

static

Functions for the Attach Menu.

Definition at line 59 of file functions.c.

                                            { /* 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 },
};

AttachmentDefaultBindings

const struct MenuOpSeq AttachmentDefaultBindings[]

static

Initial value:

= { 
  { OP_ATTACH_COLLAPSE,                "v" },
  { OP_ATTACH_DELETE,                  "d" },
  { OP_ATTACH_EDIT_TYPE,               "\005" },           
  { 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" },             
  { OP_ATTACH_VIEW,                    "\r" },             
  { OP_ATTACH_VIEW_MAILCAP,            "m" },
  { OP_ATTACH_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 95 of file functions.c.

                                                            { /* 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 },
};

AttachFunctions

const struct AttachFunction AttachFunctions[]

static

All the NeoMutt functions that the Attach supports.

Definition at line 792 of file functions.c.

                                                       {
  // 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
};