recvcmd.c

Go to the documentation of this file.

 
#include "config.h"
#include <locale.h>
#include <stdbool.h>
#include <stdio.h>
#include "mutt/lib.h"
#include "address/lib.h"
#include "config/lib.h"
#include "email/lib.h"
#include "core/lib.h"
#include "alias/lib.h"
#include "gui/lib.h"
#include "mutt.h"
#include "recvcmd.h"
#include "editor/lib.h"
#include "expando/lib.h"
#include "history/lib.h"
#include "index/lib.h"
#include "question/lib.h"
#include "send/lib.h"
#include "attach.h"
#include "globals.h"
#include "mutt_logging.h"
#ifdef ENABLE_NLS
#include <libintl.h>
#endif

static bool check_msg(struct Body *b, bool err)
{
  if (!mutt_is_message_type(b->type, b->subtype))
  {
    if (err)
      mutt_error(_("You may only bounce message/rfc822 parts"));
    return false;
  }
  return true;
}

static bool check_all_msg(struct AttachPtrArray *aa, bool err)
{
  struct AttachPtr **app = NULL;
  ARRAY_FOREACH(app, aa)
  {
    if (!check_msg((*app)->body, err))
      return false;
  }
  return true;
}

static bool check_can_decode(struct AttachPtrArray *aa)
{
  struct AttachPtr **app = NULL;
  ARRAY_FOREACH(app, aa)
  {
    if (!mutt_can_decode((*app)->body))
      return false;
  }
 
  return true;
}

static bool aa_contains_body(struct AttachPtrArray *aa, const struct Body *b)
{
  if (!b)
    return false;
 
  struct AttachPtr **app = NULL;
  ARRAY_FOREACH(app, aa)
  {
    if ((*app)->body == b)
      return true;
  }
 
  return false;
}

static short count_selected_children(struct AttachCtx *actx, short i, struct AttachPtrArray *aa)
{
  short level = actx->idx[i]->level;
  short count = 0;
 
  while ((++i < actx->idxlen) && (level < actx->idx[i]->level))
    if (aa_contains_body(aa, actx->idx[i]->body))
      count++;
 
  return count;
}

void attach_bounce_message(struct AttachPtrArray *aa, struct Mailbox *m)
{
  if (!m || ARRAY_EMPTY(aa))
    return;
 
  if (!check_all_msg(aa, 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 */
  struct AttachPtr **app = NULL;
  ARRAY_FOREACH(app, aa)
  {
    if (TAILQ_EMPTY(&(*app)->body->email->env->from))
    {
      mutt_error(_("Warning: message contains no From: header"));
      mutt_clear_error();
      break;
    }
  }
 
  /* one or more messages? */
  const int num_msg = ARRAY_SIZE(aa);
  if (num_msg == 1)
    buf_strcpy(prompt, _("Bounce message to: "));
  else
    buf_strcpy(prompt, _("Bounce messages to: "));
 
  if ((mw_get_field(buf_string(prompt), buf, MUTT_COMP_NONE, 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;
  ARRAY_FOREACH(app, aa)
  {
    if (mutt_bounce_message((*app)->fp, m, (*app)->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);
}

void mutt_attach_resend(struct AttachPtrArray *aa, struct Mailbox *m)
{
  if (!check_all_msg(aa, true))
    return;
 
  struct AttachPtr **app = NULL;
  ARRAY_FOREACH(app, aa)
  {
    mutt_resend_message((*app)->fp, m, (*app)->body->email, NeoMutt->sub);
  }
}

static struct AttachPtr *find_common_parent(struct AttachCtx *actx, struct AttachPtrArray *aa)
{
  short i;
  const short nattach = ARRAY_SIZE(aa);
 
  for (i = 0; i < actx->idxlen; i++)
    if (aa_contains_body(aa, actx->idx[i]->body))
      break;
 
  while (--i >= 0)
  {
    if (mutt_is_message_type(actx->idx[i]->body->type, actx->idx[i]->body->subtype))
    {
      const short nchildren = count_selected_children(actx, i, aa);
      if (nchildren == nattach)
        return actx->idx[i];
    }
  }
 
  return NULL;
}

static int is_parent(short i, struct AttachCtx *actx, const struct Body *b)
{
  short level = actx->idx[i]->level;
 
  while ((++i < actx->idxlen) && (actx->idx[i]->level > level))
  {
    if (actx->idx[i]->body == b)
      return true;
  }
 
  return false;
}

static struct AttachPtr *find_parent(struct AttachCtx *actx, struct AttachPtrArray *aa)
{
  struct AttachPtr *parent = NULL;
  const short nattach = ARRAY_SIZE(aa);
 
  if (nattach == 1)
  {
    struct AttachPtr **app = ARRAY_GET(aa, 0);
    struct Body *b = app ? (*app)->body : NULL;
    for (short i = 0; i < actx->idxlen; i++)
    {
      if (mutt_is_message_type(actx->idx[i]->body->type, actx->idx[i]->body->subtype) &&
          is_parent(i, actx, b))
      {
        parent = actx->idx[i];
      }
      if (actx->idx[i]->body == b)
        break;
    }
  }
  else if (nattach)
  {
    parent = find_common_parent(actx, aa);
  }
 
  return parent;
}

static void include_header(bool quote, FILE *fp_in, struct Email *e,
                           FILE *fp_out, const char *prefix)
{
  CopyHeaderFlags chflags = CH_DECODE;
  struct Buffer *prefix2 = buf_pool_get();
 
  const bool c_weed = cs_subset_bool(NeoMutt->sub, "weed");
  if (c_weed)
    chflags |= CH_WEED | CH_REORDER;
 
  if (quote)
  {
    const bool c_text_flowed = cs_subset_bool(NeoMutt->sub, "text_flowed");
    if (prefix)
    {
      buf_strcpy(prefix2, prefix);
    }
    else if (!c_text_flowed)
    {
      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(prefix2, -1, c_indent_string, NULL, -1, e, MUTT_FORMAT_NONE, NULL);
      setlocale(LC_TIME, "");
    }
    else
    {
      buf_strcpy(prefix2, ">");
    }
 
    chflags |= CH_PREFIX;
  }
 
  mutt_copy_header(fp_in, e, fp_out, chflags, quote ? buf_string(prefix2) : NULL, 0);
  buf_pool_release(&prefix2);
}

static struct Body **copy_problematic_attachments(struct Body **last,
                                                  struct AttachPtrArray *aa, bool force)
{
  struct AttachPtr **app = NULL;
  ARRAY_FOREACH(app, aa)
  {
    if (force || !mutt_can_decode((*app)->body))
    {
      if (mutt_body_copy((*app)->fp, last, (*app)->body) == -1)
        return NULL; /* XXXXX - may lead to crashes */
      last = &((*last)->next);
    }
  }
  return last;
}

static void attach_forward_bodies(struct Email *e, struct AttachCtx *actx,
                                  struct AttachPtrArray *aa)
{
  bool mime_fwd_all = false;
  bool mime_fwd_any = true;
  struct Email *e_parent = NULL;
  FILE *fp_parent = NULL;
  enum QuadOption ans = MUTT_NO;
  struct Buffer *tempfile = NULL;
  struct Buffer *prefix = buf_pool_get();
  const short nattach = ARRAY_SIZE(aa);
  struct AttachPtr **first = ARRAY_GET(aa, 0);
  struct AttachPtr *current = first ? *first : NULL;
  struct Body *b = current ? current->body : NULL;
  FILE *fp = current ? current->fp : NULL;
 
  /* First, find the parent message.
   * Note: This could be made an option by just
   * putting the following lines into an if block.  */
  struct AttachPtr *parent = find_parent(actx, aa);
  if (parent)
  {
    e_parent = parent->body->email;
    fp_parent = parent->fp;
  }
  else
  {
    e_parent = e;
    fp_parent = actx->fp_root;
  }
 
  struct Email *e_tmp = email_new();
  e_tmp->env = mutt_env_new();
  mutt_make_forward_subject(e_tmp->env, e_parent, NeoMutt->sub);
 
  tempfile = buf_pool_get();
  buf_mktemp_draft(tempfile);
  FILE *fp_tmp = mutt_file_fopen(buf_string(tempfile), "w");
  if (!fp_tmp)
  {
    mutt_error(_("Can't open temporary file %s"), buf_string(tempfile));
    email_free(&e_tmp);
    goto bail;
  }
 
  mutt_forward_intro(e_parent, fp_tmp, NeoMutt->sub);
 
  /* prepare the prefix here since we'll need it later. */
 
  const bool c_forward_quote = cs_subset_bool(NeoMutt->sub, "forward_quote");
  if (c_forward_quote)
  {
    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, NULL, -1, e_parent,
                       MUTT_FORMAT_NONE, NULL);
      setlocale(LC_TIME, "");
    }
  }
 
  include_header(c_forward_quote, fp_parent, e_parent, fp_tmp, buf_string(prefix));
 
  /* Now, we have prepared the first part of the message body: The
   * original message's header.
   *
   * The next part is more interesting: either include the message bodies,
   * or attach them.  */
  if ((!b || mutt_can_decode(b)) &&
      ((ans = query_quadoption(_("Forward as attachments?"), NeoMutt->sub, "mime_forward")) == MUTT_YES))
  {
    mime_fwd_all = true;
  }
  else if (ans == MUTT_ABORT)
  {
    goto bail;
  }
 
  /* shortcut MIMEFWDREST when there is only one attachment.
   * Is this intuitive?  */
  if (!mime_fwd_all && (nattach > 1) && !check_can_decode(aa))
  {
    ans = query_quadoption(_("Can't decode all selected attachments.  MIME-forward the others?"),
                           NeoMutt->sub, "mime_forward_rest");
    if (ans == MUTT_ABORT)
      goto bail;
    else if (ans == MUTT_NO)
      mime_fwd_any = false;
  }
 
  /* initialize a state structure */
 
  struct State state = { 0 };
  if (c_forward_quote)
    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;
  state.fp_out = fp_tmp;
 
  /* where do we append new MIME parts? */
  struct Body **last = &e_tmp->body;
 
  if (nattach == 1)
  {
    /* single body case */
 
    if (!mime_fwd_all && mutt_can_decode(b))
    {
      state.fp_in = fp;
      mutt_body_handler(b, &state);
      state_putc(&state, '\n');
    }
    else
    {
      if (mutt_body_copy(fp, last, b) == -1)
        goto bail;
    }
  }
  else
  {
    /* multiple body case */
 
    if (!mime_fwd_all)
    {
      struct AttachPtr **app = NULL;
      ARRAY_FOREACH(app, aa)
      {
        if (mutt_can_decode((*app)->body))
        {
          state.fp_in = (*app)->fp;
          mutt_body_handler((*app)->body, &state);
          state_putc(&state, '\n');
        }
      }
    }
 
    if (mime_fwd_any && !copy_problematic_attachments(last, aa, mime_fwd_all))
      goto bail;
  }
 
  mutt_forward_trailer(e_parent, fp_tmp, NeoMutt->sub);
 
  mutt_file_fclose(&fp_tmp);
  fp_tmp = NULL;
 
  /* now that we have the template, send it. */
  struct EmailArray ea = ARRAY_HEAD_INITIALIZER;
  ARRAY_ADD(&ea, e_parent);
  mutt_send_message(SEND_NONE, e_tmp, buf_string(tempfile), NULL, &ea, NeoMutt->sub);
  ARRAY_FREE(&ea);
  buf_pool_release(&tempfile);
  buf_pool_release(&prefix);
  return;
 
bail:
  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);
}

static void attach_forward_msgs(struct AttachPtrArray *aa, SendFlags flags)
{
  struct AttachPtr **first = ARRAY_GET(aa, 0);
  if (!first)
    return;
 
  struct AttachPtr *current = *first;
  FILE *fp = current->fp;
  struct Body *b = current->body;
  struct Email *e_cur = current->body->email;
  struct Email *e_tmp = NULL;
  enum QuadOption ans;
  struct Body **last = NULL;
  struct Buffer *tempfile = NULL;
  FILE *fp_tmp = NULL;
 
  CopyHeaderFlags chflags = CH_DECODE;
 
  e_tmp = email_new();
  e_tmp->env = mutt_env_new();
  mutt_make_forward_subject(e_tmp->env, e_cur, NeoMutt->sub);
 
  tempfile = buf_pool_get();
 
  ans = query_quadoption(_("Forward MIME encapsulated?"), NeoMutt->sub, "mime_forward");
  if (ans == MUTT_NO)
  {
    /* no MIME encapsulation */
 
    buf_mktemp_draft(tempfile);
    fp_tmp = mutt_file_fopen(buf_string(tempfile), "w");
    if (!fp_tmp)
    {
      mutt_error(_("Can't create %s"), buf_string(tempfile));
      goto cleanup;
    }
 
    CopyMessageFlags cmflags = MUTT_CM_NONE;
    const bool c_forward_quote = cs_subset_bool(NeoMutt->sub, "forward_quote");
    if (c_forward_quote)
    {
      chflags |= CH_PREFIX;
      cmflags |= MUTT_CM_PREFIX;
    }
 
    const bool c_forward_decode = cs_subset_bool(NeoMutt->sub, "forward_decode");
    if (c_forward_decode)
    {
      cmflags |= MUTT_CM_DECODE | MUTT_CM_CHARCONV;
      const bool c_weed = cs_subset_bool(NeoMutt->sub, "weed");
      if (c_weed)
      {
        chflags |= CH_WEED | CH_REORDER;
        cmflags |= MUTT_CM_WEED;
      }
    }
 
    if (ARRAY_SIZE(aa) == 1)
    {
      mutt_forward_intro(b->email, fp_tmp, NeoMutt->sub);
      mutt_copy_message_fp(fp_tmp, fp, b->email, cmflags, chflags, 0);
      mutt_forward_trailer(b->email, fp_tmp, NeoMutt->sub);
    }
    else
    {
      struct AttachPtr **app = NULL;
      ARRAY_FOREACH(app, aa)
      {
        mutt_forward_intro((*app)->body->email, fp_tmp, NeoMutt->sub);
        mutt_copy_message_fp(fp_tmp, (*app)->fp, (*app)->body->email, cmflags, chflags, 0);
        mutt_forward_trailer((*app)->body->email, fp_tmp, NeoMutt->sub);
      }
    }
    mutt_file_fclose(&fp_tmp);
  }
  else if (ans == MUTT_YES) /* do MIME encapsulation - we don't need to do much here */
  {
    last = &e_tmp->body;
    if (ARRAY_SIZE(aa) == 1)
    {
      mutt_body_copy(fp, last, b);
    }
    else
    {
      struct AttachPtr **app = NULL;
      ARRAY_FOREACH(app, aa)
      {
        mutt_body_copy((*app)->fp, last, (*app)->body);
        last = &((*last)->next);
      }
    }
  }
  else
  {
    email_free(&e_tmp);
  }
 
  struct EmailArray ea = ARRAY_HEAD_INITIALIZER;
  ARRAY_ADD(&ea, e_cur);
  mutt_send_message(flags, e_tmp, buf_is_empty(tempfile) ? NULL : buf_string(tempfile),
                    NULL, &ea, NeoMutt->sub);
  ARRAY_FREE(&ea);
  e_tmp = NULL; /* mutt_send_message frees this */
 
cleanup:
  email_free(&e_tmp);
  buf_pool_release(&tempfile);
}

void mutt_attach_forward(struct AttachPtrArray *aa, struct Email *e,
                         struct AttachCtx *actx, SendFlags flags)
{
  if (check_all_msg(aa, false))
  {
    attach_forward_msgs(aa, flags);
  }
  else
  {
    attach_forward_bodies(e, actx, aa);
  }
}

static int attach_reply_envelope_defaults(struct Envelope *env, struct AttachPtrArray *aa,
                                          struct Email *parent, SendFlags flags)
{
  struct Envelope *curenv = NULL;
  struct Email *e = NULL;
 
  if (parent)
  {
    curenv = parent->env;
    e = parent;
  }
  else
  {
    struct AttachPtr **app = NULL;
    ARRAY_FOREACH(app, aa)
    {
      e = (*app)->body->email;
      curenv = e->env;
      break;
    }
  }
 
  if (!curenv || !e)
  {
    mutt_error(_("Can't find any selected messages"));
    return -1;
  }
 
  if ((flags & SEND_NEWS))
  {
    /* in case followup set Newsgroups: with Followup-To: if it present */
    if (!env->newsgroups && curenv && !mutt_istr_equal(curenv->followup_to, "poster"))
    {
      env->newsgroups = mutt_str_dup(curenv->followup_to);
    }
  }
  else
  {
    if (parent)
    {
      if (mutt_fetch_recips(env, curenv, flags, NeoMutt->sub) == -1)
        return -1;
    }
    else
    {
      struct AttachPtr **app = NULL;
      ARRAY_FOREACH(app, aa)
      {
        if (mutt_fetch_recips(env, (*app)->body->email->env, flags, NeoMutt->sub) == -1)
        {
          return -1;
        }
      }
    }
 
    if ((flags & SEND_LIST_REPLY) && TAILQ_EMPTY(&env->to))
    {
      mutt_error(_("No mailing lists found"));
      return -1;
    }
 
    mutt_fix_reply_recipients(env, NeoMutt->sub);
  }
  mutt_make_misc_reply_headers(env, curenv, NeoMutt->sub);
 
  if (parent)
  {
    mutt_add_to_reference_headers(env, curenv, NeoMutt->sub);
  }
  else
  {
    struct AttachPtr **app = NULL;
    ARRAY_FOREACH(app, aa)
    {
      mutt_add_to_reference_headers(env, (*app)->body->email->env, NeoMutt->sub);
    }
  }
 
  return 0;
}

static void attach_include_reply(FILE *fp, FILE *fp_tmp, struct Email *e)
{
  CopyMessageFlags cmflags = MUTT_CM_PREFIX | MUTT_CM_DECODE | MUTT_CM_CHARCONV;
  CopyHeaderFlags chflags = CH_DECODE;
 
  mutt_make_attribution_intro(e, fp_tmp, NeoMutt->sub);
 
  const bool c_header = cs_subset_bool(NeoMutt->sub, "header");
  if (!c_header)
    cmflags |= MUTT_CM_NOHEADER;
  const bool c_weed = cs_subset_bool(NeoMutt->sub, "weed");
  if (c_weed)
  {
    chflags |= CH_WEED;
    cmflags |= MUTT_CM_WEED;
  }
 
  mutt_copy_message_fp(fp_tmp, fp, e, cmflags, chflags, 0);
  mutt_make_attribution_trailer(e, fp_tmp, NeoMutt->sub);
}

void mutt_attach_reply(struct AttachPtrArray *aa, struct Mailbox *m,
                       struct Email *e, struct AttachCtx *actx, SendFlags flags)
{
  bool mime_reply_any = false;
 
  const short nattach = ARRAY_SIZE(aa);
  struct AttachPtr **first = ARRAY_GET(aa, 0);
  if (!first)
    return;
 
  struct AttachPtr *current = *first;
  FILE *fp = current->fp;
  struct Body *b = current->body;
  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;
 
  /* Determine the parent message for the reply: either the selected
   * attachment's parent or the top-level email if not nested */
  if (!check_all_msg(aa, false))
  {
    parent = find_parent(actx, aa);
    if (parent)
    {
      e_parent = parent->body->email;
      fp_parent = parent->fp;
    }
    else
    {
      e_parent = e;
      fp_parent = actx->fp_root;
    }
  }
 
  /* Check if non-decodable attachments should be MIME-encapsulated */
  if ((nattach > 1) && !check_can_decode(aa))
  {
    const enum QuadOption ans = query_quadoption(_("Can't decode all selected 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, aa,
                                     e_parent ? e_parent : (b ? b->email : NULL),
                                     flags) == -1)
  {
    goto cleanup;
  }
 
  /* Create a temporary file for the reply body and write the quoted
   * content of the selected attachment(s) into it */
  tempfile = buf_pool_get();
  buf_mktemp_draft(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_NONE, 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 (nattach == 1)
    {
      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
    {
      struct AttachPtr **app = NULL;
      ARRAY_FOREACH(app, aa)
      {
        if (mutt_can_decode((*app)->body))
        {
          state.fp_in = (*app)->fp;
          mutt_body_handler((*app)->body, &state);
          state_putc(&state, '\n');
        }
      }
    }
 
    mutt_make_attribution_trailer(e_parent, fp_tmp, NeoMutt->sub);
 
    if (mime_reply_any && (nattach > 1) &&
        !copy_problematic_attachments(&e_tmp->body, aa, false))
    {
      goto cleanup;
    }
  }
  else
  {
    if (nattach == 1)
    {
      attach_include_reply(fp, fp_tmp, b->email);
    }
    else
    {
      struct AttachPtr **app = NULL;
      ARRAY_FOREACH(app, aa)
      {
        attach_include_reply((*app)->fp, fp_tmp, (*app)->body->email);
      }
    }
  }
 
  mutt_file_fclose(&fp_tmp);
 
  ARRAY_ADD(&ea, e_parent ? e_parent : b->email);
  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);
}

void mutt_attach_mail_sender(struct AttachPtrArray *aa)
{
  if (!check_all_msg(aa, false))
  {
    /* 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();
 
  struct AttachPtr **app = NULL;
  ARRAY_FOREACH(app, aa)
  {
    if (mutt_fetch_recips(e_tmp->env, (*app)->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_NONE, e_tmp, NULL, NULL, NULL, NeoMutt->sub);
}