Attachment Function API

Prototype for an Attachment Function. More...

Collaboration diagram for Attachment Function API:

Functions
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 -

Detailed Description

Prototype for an Attachment Function.

Parameters

priv	Private Attach data
event	Event to process

Return values

enum	FunctionRetval

Precondition

priv is not NULL

event is not NULL

Function Documentation

op_attachment_collapse()

static int op_attachment_collapse ( struct AttachPrivateData * priv, const struct KeyEvent * event )

static

toggle display of subparts - Implements attach_function_t -

Definition at line 267 of file functions.c.

{
  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_NO_ACTION;
  }
  attach_collapse(priv->actx, priv->menu);
  mutt_update_recvattach_menu(priv->actx, priv->menu, false);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_attachment_delete()

static int op_attachment_delete ( struct AttachPrivateData * priv, const struct KeyEvent * event )

static

delete the current entry - Implements attach_function_t -

Definition at line 283 of file functions.c.

{
  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"));
  }
 
  if (priv->menu->tag_prefix)
  {
    for (int i = 0; i < priv->menu->max; i++)
    {
      if (priv->actx->idx[i]->body->tagged)
      {
        if (priv->actx->idx[i]->parent_type == TYPE_MULTIPART)
        {
          priv->actx->idx[i]->body->deleted = true;
          menu_queue_redraw(priv->menu, MENU_REDRAW_INDEX);
        }
        else
        {
          mutt_message(_("Only deletion of multipart attachments is supported"));
        }
      }
    }
  }
  else
  {
    struct AttachPtr *cur_att = current_attachment(priv->actx, priv->menu);
    if (cur_att->parent_type == TYPE_MULTIPART)
    {
      cur_att->body->deleted = true;
      const bool c_resolve = cs_subset_bool(NeoMutt->sub, "resolve");
      const int index = menu_get_index(priv->menu) + 1;
      if (c_resolve && (index < priv->menu->max))
      {
        menu_set_index(priv->menu, index);
      }
      else
      {
        menu_queue_redraw(priv->menu, MENU_REDRAW_CURRENT);
      }
    }
    else
    {
      mutt_message(_("Only deletion of multipart attachments is supported"));
    }
  }
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_attachment_edit_type()

static int op_attachment_edit_type ( struct AttachPrivateData * priv, const struct KeyEvent * event )

static

edit attachment content type - Implements attach_function_t -

Definition at line 359 of file functions.c.

{
  recvattach_edit_content_type(priv->actx, priv->menu, priv->actx->email);
  menu_queue_redraw(priv->menu, MENU_REDRAW_INDEX);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_attachment_pipe()

static int op_attachment_pipe ( struct AttachPrivateData * priv, const struct KeyEvent * event )

static

pipe message/attachment to a shell command - Implements attach_function_t -

Definition at line 369 of file functions.c.

{
  struct AttachPtr *cur_att = current_attachment(priv->actx, priv->menu);
  mutt_pipe_attachment_list(priv->actx, cur_att->fp, priv->menu->tag_prefix,
                            cur_att->body, false);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_attachment_print()

static int op_attachment_print ( struct AttachPrivateData * priv, const struct KeyEvent * event )

static

print the current entry - Implements attach_function_t -

Definition at line 380 of file functions.c.

{
  struct AttachPtr *cur_att = current_attachment(priv->actx, priv->menu);
  mutt_print_attachment_list(priv->actx, cur_att->fp, priv->menu->tag_prefix,
                             cur_att->body);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_attachment_save()

static int op_attachment_save ( struct AttachPrivateData * priv, const struct KeyEvent * event )

static

save message/attachment to a mailbox/file - Implements attach_function_t -

Definition at line 391 of file functions.c.

{
  struct AttachPtr *cur_att = current_attachment(priv->actx, priv->menu);
  mutt_save_attachment_list(priv->actx, cur_att->fp, priv->menu->tag_prefix,
                            cur_att->body, priv->actx->email, priv->menu);
 
  const bool c_resolve = cs_subset_bool(NeoMutt->sub, "resolve");
  const int index = menu_get_index(priv->menu) + 1;
  if (!priv->menu->tag_prefix && c_resolve && (index < priv->menu->max))
    menu_set_index(priv->menu, index);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_attachment_undelete()

static int op_attachment_undelete ( struct AttachPrivateData * priv, const struct KeyEvent * event )

static

undelete the current entry - Implements attach_function_t -

Definition at line 407 of file functions.c.

{
  if (check_readonly(priv->mailbox))
    return FR_ERROR;
 
  if (priv->menu->tag_prefix)
  {
    for (int i = 0; i < priv->menu->max; i++)
    {
      if (priv->actx->idx[i]->body->tagged)
      {
        priv->actx->idx[i]->body->deleted = false;
        menu_queue_redraw(priv->menu, MENU_REDRAW_INDEX);
      }
    }
  }
  else
  {
    struct AttachPtr *cur_att = current_attachment(priv->actx, priv->menu);
    cur_att->body->deleted = false;
    const bool c_resolve = cs_subset_bool(NeoMutt->sub, "resolve");
    const int index = menu_get_index(priv->menu) + 1;
    if (c_resolve && (index < priv->menu->max))
    {
      menu_set_index(priv->menu, index);
    }
    else
    {
      menu_queue_redraw(priv->menu, MENU_REDRAW_CURRENT);
    }
  }
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_attachment_view()

static int op_attachment_view ( struct AttachPrivateData * priv, const struct KeyEvent * event )

static

view attachment using mailcap entry if necessary - Implements attach_function_t -

Definition at line 445 of file functions.c.

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

Here is the call graph for this function:

op_attachment_view_mailcap()

static int op_attachment_view_mailcap ( struct AttachPrivateData * priv, const struct KeyEvent * event )

static

force viewing of attachment using mailcap - Implements attach_function_t -

Definition at line 457 of file functions.c.

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

Here is the call graph for this function:

op_attachment_view_pager()

static int op_attachment_view_pager ( struct AttachPrivateData * priv, const struct KeyEvent * event )

static

view attachment in pager using copiousoutput mailcap - Implements attach_function_t -

Definition at line 470 of file functions.c.

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

Here is the call graph for this function:

op_attachment_view_text()

static int op_attachment_view_text ( struct AttachPrivateData * priv, const struct KeyEvent * event )

static

view attachment as text - Implements attach_function_t -

Definition at line 482 of file functions.c.

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

Here is the call graph for this function:

op_bounce_message()

static int op_bounce_message ( struct AttachPrivateData * priv, const struct KeyEvent * event )

static

remail a message to another user - Implements attach_function_t -

Definition at line 494 of file functions.c.

{
  if (check_attach(priv))
    return FR_ERROR;
  struct AttachPtr *cur_att = current_attachment(priv->actx, priv->menu);
  attach_bounce_message(priv->mailbox, cur_att->fp, priv->actx,
                        priv->menu->tag_prefix ? NULL : cur_att->body);
  menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_check_traditional()

static int op_check_traditional ( struct AttachPrivateData * priv, const struct KeyEvent * event )

static

check for classic PGP - Implements attach_function_t -

Definition at line 508 of file functions.c.

{
  if (((WithCrypto & APPLICATION_PGP) != 0) &&
      recvattach_pgp_check_traditional(priv->actx, priv->menu))
  {
    priv->actx->email->security = crypt_query(NULL);
    menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
  }
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_compose_to_sender()

static int op_compose_to_sender ( struct AttachPrivateData * priv, const struct KeyEvent * event )

static

compose new message to the current message sender - Implements attach_function_t -

Definition at line 522 of file functions.c.

{
  if (check_attach(priv))
    return FR_ERROR;
  struct AttachPtr *cur_att = current_attachment(priv->actx, priv->menu);
  mutt_attach_mail_sender(priv->actx, priv->menu->tag_prefix ? NULL : cur_att->body);
  menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_exit()

static int op_exit ( struct AttachPrivateData * priv, const struct KeyEvent * event )

static

exit this menu - Implements attach_function_t -

Definition at line 535 of file functions.c.

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

Here is the call graph for this function:

op_extract_keys()

static int op_extract_keys ( struct AttachPrivateData * priv, const struct KeyEvent * event )

static

extract supported public keys - Implements attach_function_t -

Definition at line 556 of file functions.c.

{
  if (!(WithCrypto & APPLICATION_PGP))
    return FR_NO_ACTION;
 
  recvattach_extract_pgp_keys(priv->actx, priv->menu);
  menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_forget_passphrase()

static int op_forget_passphrase ( struct AttachPrivateData * priv, const struct KeyEvent * event )

static

wipe passphrases from memory - Implements attach_function_t -

Definition at line 570 of file functions.c.

{
  crypt_forget_passphrase();
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_forward_message()

static int op_forward_message ( struct AttachPrivateData * priv, const struct KeyEvent * event )

static

forward a message with comments - Implements attach_function_t -

Definition at line 579 of file functions.c.

{
  if (check_attach(priv))
    return FR_ERROR;
  struct AttachPtr *cur_att = current_attachment(priv->actx, priv->menu);
  mutt_attach_forward(cur_att->fp, priv->actx->email, priv->actx,
                      priv->menu->tag_prefix ? NULL : cur_att->body, SEND_NO_FLAGS);
  menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_list_subscribe()

static int op_list_subscribe ( struct AttachPrivateData * priv, const struct KeyEvent * event )

static

subscribe to a mailing list - Implements attach_function_t -

Definition at line 593 of file functions.c.

{
  if (!check_attach(priv))
    mutt_send_list_subscribe(priv->mailbox, priv->actx->email);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_list_unsubscribe()

static int op_list_unsubscribe ( struct AttachPrivateData * priv, const struct KeyEvent * event )

static

unsubscribe from a mailing list - Implements attach_function_t -

Definition at line 603 of file functions.c.

{
  if (!check_attach(priv))
    mutt_send_list_unsubscribe(priv->mailbox, priv->actx->email);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_reply()

static int op_reply ( struct AttachPrivateData * priv, const struct KeyEvent * event )

static

reply to a message - Implements attach_function_t -

Definition at line 613 of file functions.c.

{
  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 AttachPtr *cur_att = current_attachment(priv->actx, priv->menu);
  mutt_attach_reply(cur_att->fp, priv->mailbox, priv->actx->email, priv->actx,
                    priv->menu->tag_prefix ? NULL : cur_att->body, flags);
  menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
  return FR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

op_resend()

static int op_resend ( struct AttachPrivateData * priv, const struct KeyEvent * event )

static

use the current message as a template for a new one - Implements attach_function_t -

Definition at line 637 of file functions.c.

{
  if (check_attach(priv))
    return FR_ERROR;
  struct AttachPtr *cur_att = current_attachment(priv->actx, priv->menu);
  mutt_attach_resend(cur_att->fp, priv->mailbox, priv->actx,
                     priv->menu->tag_prefix ? NULL : cur_att->body);
  menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_followup()

static int op_followup ( struct AttachPrivateData * priv, const struct KeyEvent * event )

static

followup to newsgroup - Implements attach_function_t -

Definition at line 653 of file functions.c.

{
  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?"), NeoMutt->sub,
                        "followup_to_poster") != MUTT_YES))
  {
    mutt_attach_reply(cur_att->fp, priv->mailbox, priv->actx->email, priv->actx,
                      priv->menu->tag_prefix ? NULL : cur_att->body, SEND_NEWS | SEND_REPLY);
    menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
    return FR_SUCCESS;
  }
 
  return op_reply(priv, event);
}

Here is the call graph for this function:

op_forward_to_group()

static int op_forward_to_group ( struct AttachPrivateData * priv, const struct KeyEvent * event )

static

forward to newsgroup - Implements attach_function_t -

Definition at line 681 of file functions.c.

{
  if (check_attach(priv))
    return FR_ERROR;
  struct AttachPtr *cur_att = current_attachment(priv->actx, priv->menu);
  mutt_attach_forward(cur_att->fp, priv->actx->email, priv->actx,
                      priv->menu->tag_prefix ? NULL : cur_att->body, SEND_NEWS);
  menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
  return FR_SUCCESS;
}

Here is the call graph for this function: