Attachment Function API

Prototype for an Attachment Function. More...

Collaboration diagram for Attachment Function API:

Functions
static int	op_attachment_collapse (struct AttachPrivateData *priv, int op)
	toggle display of subparts - Implements attach_function_t -
static int	op_attachment_delete (struct AttachPrivateData *priv, int op)
	delete the current entry - Implements attach_function_t -
static int	op_attachment_edit_type (struct AttachPrivateData *priv, int op)
	edit attachment content type - Implements attach_function_t -
static int	op_attachment_pipe (struct AttachPrivateData *priv, int op)
	pipe message/attachment to a shell command - Implements attach_function_t -
static int	op_attachment_print (struct AttachPrivateData *priv, int op)
	print the current entry - Implements attach_function_t -
static int	op_attachment_save (struct AttachPrivateData *priv, int op)
	save message/attachment to a mailbox/file - Implements attach_function_t -
static int	op_attachment_undelete (struct AttachPrivateData *priv, int op)
	undelete the current entry - Implements attach_function_t -
static int	op_attachment_view (struct AttachPrivateData *priv, int op)
	view attachment using mailcap entry if necessary - Implements attach_function_t -
static int	op_attachment_view_mailcap (struct AttachPrivateData *priv, int op)
	force viewing of attachment using mailcap - Implements attach_function_t -
static int	op_attachment_view_pager (struct AttachPrivateData *priv, int op)
	view attachment in pager using copiousoutput mailcap - Implements attach_function_t -
static int	op_attachment_view_text (struct AttachPrivateData *priv, int op)
	view attachment as text - Implements attach_function_t -
static int	op_bounce_message (struct AttachPrivateData *priv, int op)
	remail a message to another user - Implements attach_function_t -
static int	op_check_traditional (struct AttachPrivateData *priv, int op)
	check for classic PGP - Implements attach_function_t -
static int	op_compose_to_sender (struct AttachPrivateData *priv, int op)
	compose new message to the current message sender - Implements attach_function_t -
static int	op_exit (struct AttachPrivateData *priv, int op)
	exit this menu - Implements attach_function_t -
static int	op_extract_keys (struct AttachPrivateData *priv, int op)
	extract supported public keys - Implements attach_function_t -
static int	op_forget_passphrase (struct AttachPrivateData *priv, int op)
	wipe passphrases from memory - Implements attach_function_t -
static int	op_forward_message (struct AttachPrivateData *priv, int op)
	forward a message with comments - Implements attach_function_t -
static int	op_list_subscribe (struct AttachPrivateData *priv, int op)
	subscribe to a mailing list - Implements attach_function_t -
static int	op_list_unsubscribe (struct AttachPrivateData *priv, int op)
	unsubscribe from a mailing list - Implements attach_function_t -
static int	op_reply (struct AttachPrivateData *priv, int op)
	reply to a message - Implements attach_function_t -
static int	op_resend (struct AttachPrivateData *priv, int op)
	use the current message as a template for a new one - Implements attach_function_t -
static int	op_followup (struct AttachPrivateData *priv, int op)
	followup to newsgroup - Implements attach_function_t -
static int	op_forward_to_group (struct AttachPrivateData *priv, int op)
	forward to newsgroup - Implements attach_function_t -

Detailed Description

Prototype for an Attachment Function.

Parameters

priv	Private Attach data
op	Operation to perform, e.g. OP_ATTACHMENT_COLLAPSE

Return values

enum	FunctionRetval

Function Documentation

op_attachment_collapse()

static int op_attachment_collapse ( struct AttachPrivateData *  priv, int  op  )

static

toggle display of subparts - Implements attach_function_t -

Definition at line 253 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, int  op  )

static

delete the current entry - Implements attach_function_t -

Definition at line 269 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, int  op  )

static

edit attachment content type - Implements attach_function_t -

Definition at line 345 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, int  op  )

static

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

Definition at line 355 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, int  op  )

static

print the current entry - Implements attach_function_t -

Definition at line 366 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, int  op  )

static

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

Definition at line 377 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, int  op  )

static

undelete the current entry - Implements attach_function_t -

Definition at line 393 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, int  op  )

static

view attachment using mailcap entry if necessary - Implements attach_function_t -

Definition at line 431 of file functions.c.

{
  priv->op = mutt_attach_display_loop(priv->sub, priv->menu, 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, int  op  )

static

force viewing of attachment using mailcap - Implements attach_function_t -

Definition at line 443 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, int  op  )

static

view attachment in pager using copiousoutput mailcap - Implements attach_function_t -

Definition at line 455 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, int  op  )

static

view attachment as text - Implements attach_function_t -

Definition at line 467 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, int  op  )

static

remail a message to another user - Implements attach_function_t -

Definition at line 479 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, int  op  )

static

check for classic PGP - Implements attach_function_t -

Definition at line 493 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, int  op  )

static

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

Definition at line 507 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, int  op  )

static

exit this menu - Implements attach_function_t -

Definition at line 520 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, int  op  )

static

extract supported public keys - Implements attach_function_t -

Definition at line 541 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, int  op  )

static

wipe passphrases from memory - Implements attach_function_t -

Definition at line 555 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, int  op  )

static

forward a message with comments - Implements attach_function_t -

Definition at line 564 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, int  op  )

static

subscribe to a mailing list - Implements attach_function_t -

Definition at line 578 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, int  op  )

static

unsubscribe from a mailing list - Implements attach_function_t -

Definition at line 588 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, int  op  )

static

reply to a message - Implements attach_function_t -

Definition at line 598 of file functions.c.

{
  if (check_attach(priv))
    return FR_ERROR;
 
  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, int  op  )

static

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

Definition at line 621 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, int  op  )

static

followup to newsgroup - 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);
  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, op);
}

Here is the call graph for this function:

op_forward_to_group()

static int op_forward_to_group ( struct AttachPrivateData *  priv, int  op  )

static

forward to newsgroup - Implements attach_function_t -

Definition at line 660 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: