recvcmd.h File Reference

Send/reply with an attachment. More...

#include <stdio.h>
#include "send/lib.h"

Include dependency graph for recvcmd.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
void	attach_bounce_message (struct Mailbox *m, FILE *fp, struct AttachCtx *actx, struct Body *b)
	Bounce function, from the attachment menu.
void	mutt_attach_resend (FILE *fp, struct Mailbox *m, struct AttachCtx *actx, struct Body *b)
	Resend-message, from the attachment menu.
void	mutt_attach_forward (FILE *fp, struct Email *e, struct AttachCtx *actx, struct Body *b, SendFlags flags)
	Forward an Attachment.
void	mutt_attach_reply (FILE *fp, struct Mailbox *m, struct Email *e, struct AttachCtx *actx, struct Body *b, SendFlags flags)
	Attach a reply.
void	mutt_attach_mail_sender (struct AttachCtx *actx, struct Body *b)
	Compose an email to the sender in the email attachment.

Detailed Description

Send/reply with an attachment.

Authors

• Richard Russon

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 recvcmd.h.

Function Documentation

attach_bounce_message()

void attach_bounce_message	(	struct Mailbox *	m,
		FILE *	fp,
		struct AttachCtx *	actx,
		struct Body *	b )

Bounce function, from the attachment menu.

Parameters

m	Mailbox
fp	Handle of message
actx	Attachment context
b	Body of email

Definition at line 162 of file recvcmd.c.

{
  if (!m || !fp || !actx)
    return;
 
  if (!check_all_msg(actx, b, true))
    return;
 
  struct AddressList al = TAILQ_HEAD_INITIALIZER(al);
  struct Buffer *prompt = buf_pool_get();
  struct Buffer *buf = buf_pool_get();
 
  /* RFC5322 mandates a From: header, so warn before bouncing
   * messages without one */
  if (b)
  {
    if (TAILQ_EMPTY(&b->email->env->from))
    {
      mutt_error(_("Warning: message contains no From: header"));
      mutt_clear_error();
    }
  }
  else
  {
    for (short i = 0; i < actx->idxlen; i++)
    {
      if (actx->idx[i]->body->tagged)
      {
        if (TAILQ_EMPTY(&actx->idx[i]->body->email->env->from))
        {
          mutt_error(_("Warning: message contains no From: header"));
          mutt_clear_error();
          break;
        }
      }
    }
  }
 
  /* one or more messages? */
  int num_msg = b ? 1 : count_tagged(actx);
  if (num_msg == 1)
    buf_strcpy(prompt, _("Bounce message to: "));
  else
    buf_strcpy(prompt, _("Bounce tagged messages to: "));
 
  if ((mw_get_field(buf_string(prompt), buf, MUTT_COMP_NO_FLAGS, HC_ALIAS,
                    &CompleteAliasOps, NULL) != 0) ||
      buf_is_empty(buf))
  {
    goto done;
  }
 
  mutt_addrlist_parse(&al, buf_string(buf));
  if (TAILQ_EMPTY(&al))
  {
    mutt_error(_("Error parsing address"));
    goto done;
  }
 
  mutt_expand_aliases(&al);
 
  char *err = NULL;
  if (mutt_addrlist_to_intl(&al, &err) < 0)
  {
    mutt_error(_("Bad IDN: '%s'"), err);
    FREE(&err);
    goto done;
  }
 
  buf_reset(buf);
  buf_alloc(buf, 8192);
  mutt_addrlist_write(&al, buf, true);
 
  buf_printf(prompt, ngettext("Bounce message to %s?", "Bounce messages to %s?", num_msg),
             buf_string(buf));
 
  if (query_quadoption(buf_string(prompt), NeoMutt->sub, "bounce") != MUTT_YES)
  {
    msgwin_clear_text(NULL);
    mutt_message(ngettext("Message not bounced", "Messages not bounced", num_msg));
    goto done;
  }
 
  msgwin_clear_text(NULL);
 
  int rc = 0;
  if (b)
  {
    rc = mutt_bounce_message(fp, m, b->email, &al, NeoMutt->sub);
  }
  else
  {
    for (short i = 0; i < actx->idxlen; i++)
    {
      if (actx->idx[i]->body->tagged)
      {
        if (mutt_bounce_message(actx->idx[i]->fp, m, actx->idx[i]->body->email,
                                &al, NeoMutt->sub))
        {
          rc = 1;
        }
      }
    }
  }
 
  if (rc == 0)
    mutt_message(ngettext("Message bounced", "Messages bounced", num_msg));
  else
    mutt_error(ngettext("Error bouncing message", "Error bouncing messages", num_msg));
 
done:
  mutt_addrlist_clear(&al);
  buf_pool_release(&buf);
  buf_pool_release(&prompt);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_attach_resend()

void mutt_attach_resend	(	FILE *	fp,
		struct Mailbox *	m,
		struct AttachCtx *	actx,
		struct Body *	b )

Resend-message, from the attachment menu.

Parameters

fp	File containing email
m	Current mailbox
actx	Attachment context
b	Attachment

Definition at line 286 of file recvcmd.c.

{
  if (!check_all_msg(actx, b, true))
    return;
 
  if (b)
  {
    mutt_resend_message(fp, m, b->email, NeoMutt->sub);
  }
  else
  {
    for (short i = 0; i < actx->idxlen; i++)
    {
      if (actx->idx[i]->body->tagged)
      {
        mutt_resend_message(actx->idx[i]->fp, m, actx->idx[i]->body->email,
                            NeoMutt->sub);
      }
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_attach_forward()

void mutt_attach_forward	(	FILE *	fp,
		struct Email *	e,
		struct AttachCtx *	actx,
		struct Body *	b,
		SendFlags	flags )

Forward an Attachment.

Parameters

fp	Handle to the attachment
e	Email
actx	Attachment Context
b	Current message
flags	Send mode, see SendFlags

Definition at line 789 of file recvcmd.c.

{
  if (check_all_msg(actx, b, false))
  {
    attach_forward_msgs(fp, actx, b, flags);
  }
  else
  {
    const short nattach = count_tagged(actx);
    attach_forward_bodies(fp, e, actx, b, nattach);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_attach_reply()

void mutt_attach_reply	(	FILE *	fp,
		struct Mailbox *	m,
		struct Email *	e,
		struct AttachCtx *	actx,
		struct Body *	b,
		SendFlags	flags )

Attach a reply.

Parameters

fp	File handle to reply
m	Mailbox
e	Email
actx	Attachment Context
b	Current message
flags	Send mode, see SendFlags

Definition at line 945 of file recvcmd.c.

{
  bool mime_reply_any = false;
 
  short nattach = 0;
  struct AttachPtr *parent = NULL;
  struct Email *e_parent = NULL;
  FILE *fp_parent = NULL;
  struct Email *e_tmp = NULL;
  FILE *fp_tmp = NULL;
  struct Buffer *tempfile = NULL;
  struct EmailArray ea = ARRAY_HEAD_INITIALIZER;
 
  struct Buffer *prefix = buf_pool_get();
 
  if (flags & SEND_NEWS)
    OptNewsSend = true;
  else
    OptNewsSend = false;
 
  if (!check_all_msg(actx, b, false))
  {
    nattach = count_tagged(actx);
    parent = find_parent(actx, b, nattach);
    if (parent)
    {
      e_parent = parent->body->email;
      fp_parent = parent->fp;
    }
    else
    {
      e_parent = e;
      fp_parent = actx->fp_root;
    }
  }
 
  if ((nattach > 1) && !check_can_decode(actx, b))
  {
    const enum QuadOption ans = query_quadoption(_("Can't decode all tagged attachments.  MIME-encapsulate the others?"),
                                                 NeoMutt->sub, "mime_forward_rest");
    if (ans == MUTT_ABORT)
      goto cleanup;
    if (ans == MUTT_YES)
      mime_reply_any = true;
  }
  else if (nattach == 1)
  {
    mime_reply_any = true;
  }
 
  e_tmp = email_new();
  e_tmp->env = mutt_env_new();
 
  if (attach_reply_envelope_defaults(e_tmp->env, actx,
                                     e_parent ? e_parent : (b ? b->email : NULL),
                                     flags) == -1)
  {
    goto cleanup;
  }
 
  tempfile = buf_pool_get();
  buf_mktemp(tempfile);
  fp_tmp = mutt_file_fopen(buf_string(tempfile), "w");
  if (!fp_tmp)
  {
    mutt_error(_("Can't create %s"), buf_string(tempfile));
    goto cleanup;
  }
 
  if (e_parent)
  {
    mutt_make_attribution_intro(e_parent, fp_tmp, NeoMutt->sub);
 
    struct State state = { 0 };
    state.fp_out = fp_tmp;
 
    const bool c_text_flowed = cs_subset_bool(NeoMutt->sub, "text_flowed");
    if (c_text_flowed)
    {
      buf_strcpy(prefix, ">");
    }
    else
    {
      const char *const c_attribution_locale = cs_subset_string(NeoMutt->sub, "attribution_locale");
      const struct Expando *c_indent_string = cs_subset_expando(NeoMutt->sub, "indent_string");
      setlocale(LC_TIME, NONULL(c_attribution_locale));
      mutt_make_string(prefix, -1, c_indent_string, m, -1, e_parent,
                       MUTT_FORMAT_NO_FLAGS, NULL);
      setlocale(LC_TIME, "");
    }
 
    state.prefix = buf_string(prefix);
    state.flags = STATE_CHARCONV;
 
    const bool c_weed = cs_subset_bool(NeoMutt->sub, "weed");
    if (c_weed)
      state.flags |= STATE_WEED;
 
    const bool c_header = cs_subset_bool(NeoMutt->sub, "header");
    if (c_header)
      include_header(true, fp_parent, e_parent, fp_tmp, buf_string(prefix));
 
    if (b)
    {
      if (mutt_can_decode(b))
      {
        state.fp_in = fp;
        mutt_body_handler(b, &state);
        state_putc(&state, '\n');
      }
      else
      {
        mutt_body_copy(fp, &e_tmp->body, b);
      }
    }
    else
    {
      for (short i = 0; i < actx->idxlen; i++)
      {
        if (actx->idx[i]->body->tagged && mutt_can_decode(actx->idx[i]->body))
        {
          state.fp_in = actx->idx[i]->fp;
          mutt_body_handler(actx->idx[i]->body, &state);
          state_putc(&state, '\n');
        }
      }
    }
 
    mutt_make_attribution_trailer(e_parent, fp_tmp, NeoMutt->sub);
 
    if (mime_reply_any && !b && !copy_problematic_attachments(&e_tmp->body, actx, false))
    {
      goto cleanup;
    }
  }
  else
  {
    if (b)
    {
      attach_include_reply(fp, fp_tmp, b->email);
    }
    else
    {
      for (short i = 0; i < actx->idxlen; i++)
      {
        if (actx->idx[i]->body->tagged)
          attach_include_reply(actx->idx[i]->fp, fp_tmp, actx->idx[i]->body->email);
      }
    }
  }
 
  mutt_file_fclose(&fp_tmp);
 
  ARRAY_ADD(&ea, e_parent ? e_parent : (b ? b->email : NULL));
  if (mutt_send_message(flags, e_tmp, buf_string(tempfile), NULL, &ea, NeoMutt->sub) == 0)
  {
    mutt_set_flag(m, e, MUTT_REPLIED, true, true);
  }
  e_tmp = NULL; /* mutt_send_message frees this */
 
cleanup:
  if (fp_tmp)
  {
    mutt_file_fclose(&fp_tmp);
    mutt_file_unlink(buf_string(tempfile));
  }
  buf_pool_release(&tempfile);
  buf_pool_release(&prefix);
  email_free(&e_tmp);
  ARRAY_FREE(&ea);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_attach_mail_sender()

void mutt_attach_mail_sender	(	struct AttachCtx *	actx,
		struct Body *	b )

Compose an email to the sender in the email attachment.

Parameters

actx	Attachment Context
b	Current attachment

Definition at line 1123 of file recvcmd.c.

{
  if (!check_all_msg(actx, b, 0))
  {
    /* L10N: You will see this error message if you invoke <compose-to-sender>
       when you are on a normal attachment.  */
    mutt_error(_("You may only compose to sender with message/rfc822 parts"));
    return;
  }
 
  struct Email *e_tmp = email_new();
  e_tmp->env = mutt_env_new();
 
  if (b)
  {
    if (mutt_fetch_recips(e_tmp->env, b->email->env, SEND_TO_SENDER, NeoMutt->sub) == -1)
    {
      email_free(&e_tmp);
      return;
    }
  }
  else
  {
    for (int i = 0; i < actx->idxlen; i++)
    {
      if (actx->idx[i]->body->tagged &&
          (mutt_fetch_recips(e_tmp->env, actx->idx[i]->body->email->env,
                             SEND_TO_SENDER, NeoMutt->sub) == -1))
      {
        email_free(&e_tmp);
        return;
      }
    }
  }
 
  // This call will free e_tmp for us
  mutt_send_message(SEND_NO_FLAGS, e_tmp, NULL, NULL, NULL, NeoMutt->sub);
}

Here is the call graph for this function:

Here is the caller graph for this function: