recvcmd.c File Reference

Send/reply with an attachment. More...

#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"
#include <libintl.h>

Include dependency graph for recvcmd.c:

Go to the source code of this file.

Functions
static bool	check_msg (struct Body *b, bool err)
	Are we working with an RFC822 message.
static bool	check_all_msg (struct AttachCtx *actx, struct Body *b, bool err)
	Are all the Attachments RFC822 messages?
static bool	check_can_decode (struct AttachCtx *actx, struct Body *b)
	Can we decode all tagged attachments?
static short	count_tagged (struct AttachCtx *actx)
	Count the number of tagged attachments.
static short	count_tagged_children (struct AttachCtx *actx, short i)
	Tagged children below a multipart/message attachment.
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.
static struct AttachPtr *	find_common_parent (struct AttachCtx *actx, short nattach)
	Find a common parent message for the tagged attachments.
static int	is_parent (short i, struct AttachCtx *actx, const struct Body *b)
	Check whether one attachment is the parent of another.
static struct AttachPtr *	find_parent (struct AttachCtx *actx, struct Body *b, short nattach)
	Find the parent of an Attachment.
static void	include_header (bool quote, FILE *fp_in, struct Email *e, FILE *fp_out, const char *prefix)
	Write an email header to a file, optionally quoting it.
static struct Body **	copy_problematic_attachments (struct Body **last, struct AttachCtx *actx, bool force)
	Attach the body parts which can't be decoded.
static void	attach_forward_bodies (FILE *fp, struct Email *e, struct AttachCtx *actx, struct Body *b, short nattach)
	Forward one or several MIME bodies.
static void	attach_forward_msgs (FILE *fp, struct AttachCtx *actx, struct Body *b, SendFlags flags)
	Forward one or several message-type attachments.
void	mutt_attach_forward (FILE *fp, struct Email *e, struct AttachCtx *actx, struct Body *b, SendFlags flags)
	Forward an Attachment.
static int	attach_reply_envelope_defaults (struct Envelope *env, struct AttachCtx *actx, struct Email *parent, SendFlags flags)
	Create the envelope defaults for a reply.
static void	attach_include_reply (FILE *fp, FILE *fp_tmp, struct Email *e)
	This is very similar to send.c's include_reply()
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

• Thomas Roessler
• Richard Russon
• Pietro Cerutti
• Leon Philman
• Tóth János

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.c.

Function Documentation

check_msg()

static bool check_msg ( struct Body * b, bool err )

static

Are we working with an RFC822 message.

Parameters

b	Body of email
err	If true, display a message if this isn't an RFC822 message

Return values

true	This is an RFC822 message

some helper functions to verify that we are exclusively operating on message/rfc822 attachments

Definition at line 68 of file recvcmd.c.

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

Here is the call graph for this function:

Here is the caller graph for this function:

check_all_msg()

static bool check_all_msg ( struct AttachCtx * actx, struct Body * b, bool err )

static

Are all the Attachments RFC822 messages?

Parameters

actx	Attachment context
b	Current message
err	If true, report errors

Return values

true	All parts are RFC822 messages

Definition at line 86 of file recvcmd.c.

{
  if (b && !check_msg(b, err))
    return false;
  if (!b)
  {
    for (short i = 0; i < actx->idxlen; i++)
    {
      if (actx->idx[i]->body->tagged)
      {
        if (!check_msg(actx->idx[i]->body, err))
          return false;
      }
    }
  }
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

check_can_decode()

static bool check_can_decode ( struct AttachCtx * actx, struct Body * b )

static

Can we decode all tagged attachments?

Parameters

actx	Attachment context
b	Body of email

Return values

true	All tagged attachments are decodable

Definition at line 110 of file recvcmd.c.

{
  if (b)
    return mutt_can_decode(b);
 
  for (short i = 0; i < actx->idxlen; i++)
    if (actx->idx[i]->body->tagged && !mutt_can_decode(actx->idx[i]->body))
      return false;
 
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

count_tagged()

static short count_tagged ( struct AttachCtx * actx )

static

Count the number of tagged attachments.

Parameters

actx	Attachment context

Return values

num	Number of tagged attachments

Definition at line 127 of file recvcmd.c.

{
  short count = 0;
  for (short i = 0; i < actx->idxlen; i++)
    if (actx->idx[i]->body->tagged)
      count++;
 
  return count;
}

Here is the caller graph for this function:

count_tagged_children()

static short count_tagged_children ( struct AttachCtx * actx, short i )

static

Tagged children below a multipart/message attachment.

Parameters

actx	Attachment context
i	Index of first attachment

Return values

num	Number of tagged attachments

Definition at line 143 of file recvcmd.c.

{
  short level = actx->idx[i]->level;
  short count = 0;
 
  while ((++i < actx->idxlen) && (level < actx->idx[i]->level))
    if (actx->idx[i]->body->tagged)
      count++;
 
  return count;
}

Here is the caller graph for this function:

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:

find_common_parent()

static struct AttachPtr * find_common_parent ( struct AttachCtx * actx, short nattach )

static

Find a common parent message for the tagged attachments.

Parameters

actx	Attachment context
nattach	Number of tagged attachments

Return values

ptr	Parent attachment
NULL	Failure, no common parent

Definition at line 315 of file recvcmd.c.

{
  short i;
  short nchildren;
 
  for (i = 0; i < actx->idxlen; i++)
    if (actx->idx[i]->body->tagged)
      break;
 
  while (--i >= 0)
  {
    if (mutt_is_message_type(actx->idx[i]->body->type, actx->idx[i]->body->subtype))
    {
      nchildren = count_tagged_children(actx, i);
      if (nchildren == nattach)
        return actx->idx[i];
    }
  }
 
  return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

is_parent()

static int is_parent ( short i, struct AttachCtx * actx, const struct Body * b )

static

Check whether one attachment is the parent of another.

Parameters

i	Index of parent Attachment
actx	Attachment context
b	Potential child Attachment

Return values

true	Attachment

check whether attachment i is a parent of the attachment pointed to by b

Note

This and the calling procedure could be optimized quite a bit. For now, it's not worth the effort.

Definition at line 349 of file recvcmd.c.

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

Here is the caller graph for this function:

find_parent()

static struct AttachPtr * find_parent ( struct AttachCtx * actx, struct Body * b, short nattach )

static

Find the parent of an Attachment.

Parameters

actx	Attachment context
b	Attachment (OPTIONAL)
nattach	Use the nth attachment

Return values

ptr	Parent attachment
NULL	No parent exists

Definition at line 370 of file recvcmd.c.

{
  struct AttachPtr *parent = NULL;
 
  if (b)
  {
    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, nattach);
  }
 
  return parent;
}

Here is the call graph for this function:

Here is the caller graph for this function:

include_header()

static void include_header ( bool quote, FILE * fp_in, struct Email * e, FILE * fp_out, const char * prefix )

static

Write an email header to a file, optionally quoting it.

Parameters

quote	If true, prefix the lines
fp_in	File to read from
e	Email
fp_out	File to write to
prefix	Prefix for each line (OPTIONAL)

Definition at line 403 of file recvcmd.c.

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

Here is the call graph for this function:

Here is the caller graph for this function:

copy_problematic_attachments()

static struct Body ** copy_problematic_attachments ( struct Body ** last, struct AttachCtx * actx, bool force )

static

Attach the body parts which can't be decoded.

Parameters

[out]	last	Body pointer to update
[in]	actx	Attachment context
[in]	force	If true, attach parts that can't be decoded

Return values

ptr	Pointer to last Body part

This code is shared by forwarding and replying.

Definition at line 449 of file recvcmd.c.

{
  for (short i = 0; i < actx->idxlen; i++)
  {
    if (actx->idx[i]->body->tagged && (force || !mutt_can_decode(actx->idx[i]->body)))
    {
      if (mutt_body_copy(actx->idx[i]->fp, last, actx->idx[i]->body) == -1)
        return NULL; /* XXXXX - may lead to crashes */
      last = &((*last)->next);
    }
  }
  return last;
}

Here is the call graph for this function:

Here is the caller graph for this function:

attach_forward_bodies()

static void attach_forward_bodies ( FILE * fp, struct Email * e, struct AttachCtx * actx, struct Body * b, short nattach )

static

Forward one or several MIME bodies.

Parameters

fp	File to read from
e	Email
actx	Attachment Context
b	Body of email
nattach	Number of tagged attachments

(non-message types)

Definition at line 474 of file recvcmd.c.

{
  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();
 
  /* 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, b, nattach);
  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(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_NO_FLAGS, 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 && !b && (nattach > 1) && !check_can_decode(actx, b))
  {
    ans = query_quadoption(_("Can't decode all tagged 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 (b)
  {
    /* 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)
    {
      for (int 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');
        }
      }
    }
 
    if (mime_fwd_any && !copy_problematic_attachments(last, actx, 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_NO_FLAGS, 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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

attach_forward_msgs()

static void attach_forward_msgs ( FILE * fp, struct AttachCtx * actx, struct Body * b, SendFlags flags )

static

Forward one or several message-type attachments.

Parameters

fp	File handle to attachment
actx	Attachment Context
b	Attachment to forward (OPTIONAL)
flags	Send mode, see SendFlags

This is different from the previous function since we want to mimic the index menu's behavior.

Code reuse from mutt_send_message() is not possible here. It relies on a context structure to find messages, while, on the attachment menu, messages are referenced through the attachment index.

Definition at line 658 of file recvcmd.c.

{
  struct Email *e_cur = NULL;
  struct Email *e_tmp = NULL;
  enum QuadOption ans;
  struct Body **last = NULL;
  struct Buffer *tempfile = NULL;
  FILE *fp_tmp = NULL;
 
  CopyHeaderFlags chflags = CH_DECODE;
 
  if (b)
  {
    e_cur = b->email;
  }
  else
  {
    for (short i = 0; i < actx->idxlen; i++)
    {
      if (actx->idx[i]->body->tagged)
      {
        e_cur = actx->idx[i]->body->email;
        break;
      }
    }
  }
 
  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(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_NO_FLAGS;
    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 (b)
    {
      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
    {
      for (short i = 0; i < actx->idxlen; i++)
      {
        if (actx->idx[i]->body->tagged)
        {
          mutt_forward_intro(actx->idx[i]->body->email, fp_tmp, NeoMutt->sub);
          mutt_copy_message_fp(fp_tmp, actx->idx[i]->fp,
                               actx->idx[i]->body->email, cmflags, chflags, 0);
          mutt_forward_trailer(actx->idx[i]->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 (b)
    {
      mutt_body_copy(fp, last, b);
    }
    else
    {
      for (short i = 0; i < actx->idxlen; i++)
      {
        if (actx->idx[i]->body->tagged)
        {
          mutt_body_copy(actx->idx[i]->fp, last, actx->idx[i]->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);
}

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:

attach_reply_envelope_defaults()

static int attach_reply_envelope_defaults ( struct Envelope * env, struct AttachCtx * actx, struct Email * parent, SendFlags flags )

static

Create the envelope defaults for a reply.

Parameters

env	Envelope to fill in
actx	Attachment Context
parent	Parent Email
flags	Flags, see SendFlags

Return values

0	Success
-1	Error

This function can be invoked in two ways.

Either, parent is NULL. In this case, all tagged bodies are of a message type, and the header information is fetched from them.

Or, parent is non-NULL. In this case, cur is the common parent of all the tagged attachments.

Note that this code is horribly similar to envelope_defaults() from send.c.

Definition at line 822 of file recvcmd.c.

{
  struct Envelope *curenv = NULL;
  struct Email *e = NULL;
 
  if (parent)
  {
    curenv = parent->env;
    e = parent;
  }
  else
  {
    for (short i = 0; i < actx->idxlen; i++)
    {
      if (actx->idx[i]->body->tagged)
      {
        e = actx->idx[i]->body->email;
        curenv = e->env;
        break;
      }
    }
  }
 
  if (!curenv || !e)
  {
    mutt_error(_("Can't find any tagged 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
    {
      for (short i = 0; i < actx->idxlen; i++)
      {
        if (actx->idx[i]->body->tagged &&
            (mutt_fetch_recips(env, actx->idx[i]->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
  {
    for (short i = 0; i < actx->idxlen; i++)
    {
      if (actx->idx[i]->body->tagged)
      {
        mutt_add_to_reference_headers(env, actx->idx[i]->body->email->env,
                                      NeoMutt->sub);
      }
    }
  }
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

attach_include_reply()

static void attach_include_reply ( FILE * fp, FILE * fp_tmp, struct Email * e )

static

This is very similar to send.c's include_reply()

Parameters

fp	File handle to attachment
fp_tmp	File handle to temporary file
e	Email

Definition at line 915 of file recvcmd.c.

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

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: