Attach Function API

Prototype for a Attach Function. More...

Collaboration diagram for Attach Function API:

Functions
static int	op_attach_collapse (struct AttachFunctionData *fdata, const struct KeyEvent *event)
	toggle display of subparts - Implements attach_function_t -
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_quit (struct AttachFunctionData *fdata, const struct KeyEvent *event)
	Save changes and exit this dialog - 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_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 -

Detailed Description

Prototype for a Attach Function.

Parameters

fdata	Attach Function context data
event	Event to process

Return values

enum	FunctionRetval

Precondition

fdata is not NULL

event is not NULL

Function Documentation

op_attach_collapse()

int op_attach_collapse ( struct AttachFunctionData * fdata, const struct KeyEvent * event )

static

toggle display of subparts - Implements attach_function_t -

Definition at line 247 of file functions.c.

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

Here is the call graph for this function:

op_attach_delete()

int op_attach_delete ( struct AttachFunctionData * fdata, const struct KeyEvent * event )

static

delete the current entry - Implements attach_function_t -

Supports repeat-count: 5<delete-entry> deletes the current entry and the next 4 (only multipart attachments can be deleted; non-multipart entries in the working set are silently skipped). Overruns are silently capped at the end of the list.

Definition at line 311 of file functions.c.

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

Here is the call graph for this function:

op_attach_edit_type()

int op_attach_edit_type ( struct AttachFunctionData * fdata, const struct KeyEvent * event )

static

edit attachment content type - Implements attach_function_t -

Definition at line 391 of file functions.c.

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

Here is the call graph for this function:

op_attach_pipe()

int op_attach_pipe ( struct AttachFunctionData * fdata, const struct KeyEvent * event )

static

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

Definition at line 402 of file functions.c.

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

Here is the call graph for this function:

op_attach_print()

int op_attach_print ( struct AttachFunctionData * fdata, const struct KeyEvent * event )

static

print the current entry - Implements attach_function_t -

Definition at line 415 of file functions.c.

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

Here is the call graph for this function:

op_attach_save()

int op_attach_save ( struct AttachFunctionData * fdata, const struct KeyEvent * event )

static

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

Definition at line 428 of file functions.c.

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

Here is the call graph for this function:

op_attach_undelete()

int op_attach_undelete ( struct AttachFunctionData * fdata, const struct KeyEvent * event )

static

undelete the current entry - Implements attach_function_t -

Supports repeat-count: 5<undelete-entry> undeletes the current entry and the next 4. Overruns are silently capped at the end of the list.

Definition at line 449 of file functions.c.

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

Here is the call graph for this function:

op_attach_view()

int op_attach_view ( struct AttachFunctionData * fdata, const struct KeyEvent * event )

static

view attachment using mailcap entry if necessary - Implements attach_function_t -

This function handles:

• OP_ATTACH_VIEW
• OP_DISPLAY_HEADERS

Definition at line 501 of file functions.c.

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

Here is the call graph for this function:

op_attach_view_mailcap()

int op_attach_view_mailcap ( struct AttachFunctionData * fdata, const struct KeyEvent * event )

static

force viewing of attachment using mailcap - Implements attach_function_t -

Definition at line 514 of file functions.c.

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

Here is the call graph for this function:

op_attach_view_pager()

int op_attach_view_pager ( struct AttachFunctionData * fdata, const struct KeyEvent * event )

static

view attachment in pager using copiousoutput mailcap - Implements attach_function_t -

Definition at line 527 of file functions.c.

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

Here is the call graph for this function:

op_attach_view_text()

int op_attach_view_text ( struct AttachFunctionData * fdata, const struct KeyEvent * event )

static

view attachment as text - Implements attach_function_t -

Definition at line 540 of file functions.c.

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

Here is the call graph for this function:

op_bounce_message()

int op_bounce_message ( struct AttachFunctionData * fdata, const struct KeyEvent * event )

static

remail a message to another user - Implements attach_function_t -

Definition at line 553 of file functions.c.

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

Here is the call graph for this function:

op_check_traditional()

int op_check_traditional ( struct AttachFunctionData * fdata, const struct KeyEvent * event )

static

check for classic PGP - Implements attach_function_t -

Definition at line 569 of file functions.c.

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

Here is the call graph for this function:

op_compose_to_sender()

int op_compose_to_sender ( struct AttachFunctionData * fdata, const struct KeyEvent * event )

static

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

Definition at line 586 of file functions.c.

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

Here is the call graph for this function:

op_quit()

int op_quit ( struct AttachFunctionData * fdata, const struct KeyEvent * event )

static

Save changes and exit this dialog - Implements attach_function_t -.

Definition at line 602 of file functions.c.

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

Here is the call graph for this function:

op_extract_keys()

int op_extract_keys ( struct AttachFunctionData * fdata, const struct KeyEvent * event )

static

extract supported public keys - Implements attach_function_t -

Definition at line 624 of file functions.c.

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

Here is the call graph for this function:

op_forward_message()

int op_forward_message ( struct AttachFunctionData * fdata, const struct KeyEvent * event )

static

forward a message with comments - Implements attach_function_t -

Definition at line 642 of file functions.c.

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

Here is the call graph for this function:

op_list_subscribe()

int op_list_subscribe ( struct AttachFunctionData * fdata, const struct KeyEvent * event )

static

subscribe to a mailing list - Implements attach_function_t -

Definition at line 658 of file functions.c.

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

Here is the call graph for this function:

op_list_unsubscribe()

int op_list_unsubscribe ( struct AttachFunctionData * fdata, const struct KeyEvent * event )

static

unsubscribe from a mailing list - Implements attach_function_t -

Definition at line 670 of file functions.c.

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

Here is the call graph for this function:

op_reply()

int op_reply ( struct AttachFunctionData * fdata, const struct KeyEvent * event )

static

reply to a message - Implements attach_function_t -

This function handles:

• OP_GROUP_CHAT_REPLY
• OP_GROUP_REPLY
• OP_LIST_REPLY
• OP_REPLY

Definition at line 688 of file functions.c.

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

Here is the call graph for this function:

Here is the caller graph for this function:

op_resend()

int op_resend ( struct AttachFunctionData * fdata, const struct KeyEvent * event )

static

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

Definition at line 714 of file functions.c.

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

Here is the call graph for this function:

op_followup()

int op_followup ( struct AttachFunctionData * fdata, const struct KeyEvent * event )

static

followup to newsgroup - Implements attach_function_t -

Definition at line 732 of file functions.c.

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

Here is the call graph for this function:

op_forward_to_group()

int op_forward_to_group ( struct AttachFunctionData * fdata, const struct KeyEvent * event )

static

forward to newsgroup - Implements attach_function_t -

Definition at line 763 of file functions.c.

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

Here is the call graph for this function: