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 AttachPtrArray *aa, bool err)
	Are all the selected Attachments RFC822 messages?
static bool	check_can_decode (struct AttachPtrArray *aa)
	Can we decode all selected attachments?
static bool	aa_contains_body (struct AttachPtrArray *aa, const struct Body *b)
	Does the selection contain a Body?
static short	count_selected_children (struct AttachCtx *actx, short i, struct AttachPtrArray *aa)
	Selected children below a multipart/message attachment.
void	attach_bounce_message (struct AttachPtrArray *aa, struct Mailbox *m)
	Bounce function, from the attachment menu.
void	mutt_attach_resend (struct AttachPtrArray *aa, struct Mailbox *m)
	Resend-message, from the attachment menu.
static struct AttachPtr *	find_common_parent (struct AttachCtx *actx, struct AttachPtrArray *aa)
	Find a common parent message for the selected 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 AttachPtrArray *aa)
	Find the parent of a selected Attachment set.
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 AttachPtrArray *aa, bool force)
	Attach the body parts which can't be decoded.
static void	attach_forward_bodies (struct Email *e, struct AttachCtx *actx, struct AttachPtrArray *aa)
	Forward one or several MIME bodies.
static void	attach_forward_msgs (struct AttachPtrArray *aa, SendFlags flags)
	Forward one or several message-type attachments.
void	mutt_attach_forward (struct AttachPtrArray *aa, struct Email *e, struct AttachCtx *actx, SendFlags flags)
	Forward selected attachments.
static int	attach_reply_envelope_defaults (struct Envelope *env, struct AttachPtrArray *aa, 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 (struct AttachPtrArray *aa, struct Mailbox *m, struct Email *e, struct AttachCtx *actx, SendFlags flags)
	Attach a reply.
void	mutt_attach_mail_sender (struct AttachPtrArray *aa)
	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()

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()

bool check_all_msg ( struct AttachPtrArray * aa, bool err )

static

Are all the selected Attachments RFC822 messages?

Parameters

aa	Selected attachments
err	If true, report errors

Return values

true	All parts are RFC822 messages

Definition at line 85 of file recvcmd.c.

{
  struct AttachPtr **app = NULL;
  ARRAY_FOREACH(app, aa)
  {
    if (!check_msg((*app)->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()

bool check_can_decode ( struct AttachPtrArray * aa )

static

Can we decode all selected attachments?

Parameters

aa	Selected attachments

Return values

true	All selected attachments are decodable

Definition at line 101 of file recvcmd.c.

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

Here is the call graph for this function:

Here is the caller graph for this function:

aa_contains_body()

bool aa_contains_body ( struct AttachPtrArray * aa, const struct Body * b )

static

Does the selection contain a Body?

Parameters

aa	Selected attachments
b	Candidate Body

Return values

true	Body is selected

Definition at line 119 of file recvcmd.c.

{
  if (!b)
    return false;
 
  struct AttachPtr **app = NULL;
  ARRAY_FOREACH(app, aa)
  {
    if ((*app)->body == b)
      return true;
  }
 
  return false;
}

Here is the caller graph for this function:

count_selected_children()

short count_selected_children ( struct AttachCtx * actx, short i, struct AttachPtrArray * aa )

static

Selected children below a multipart/message attachment.

Parameters

actx	Attachment context
i	Index of first attachment
aa	Selected attachments

Return values

num	Number of selected attachments

Definition at line 141 of file recvcmd.c.

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

Here is the call graph for this function:

Here is the caller graph for this function:

attach_bounce_message()

void attach_bounce_message	(	struct AttachPtrArray *	aa,
		struct Mailbox *	m )

Bounce function, from the attachment menu.

Parameters

aa	Selected attachments
m	Mailbox

Definition at line 158 of file recvcmd.c.

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

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_attach_resend()

void mutt_attach_resend	(	struct AttachPtrArray *	aa,
		struct Mailbox *	m )

Resend-message, from the attachment menu.

Parameters

aa	Selected attachments
m	Current mailbox

Definition at line 255 of file recvcmd.c.

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

Here is the call graph for this function:

Here is the caller graph for this function:

find_common_parent()

struct AttachPtr * find_common_parent ( struct AttachCtx * actx, struct AttachPtrArray * aa )

static

Find a common parent message for the selected attachments.

Parameters

actx	Attachment context
aa	Selected attachments

Return values

ptr	Parent attachment
NULL	Failure, no common parent

Definition at line 274 of file recvcmd.c.

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

Here is the call graph for this function:

Here is the caller graph for this function:

is_parent()

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 308 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()

struct AttachPtr * find_parent ( struct AttachCtx * actx, struct AttachPtrArray * aa )

static

Find the parent of a selected Attachment set.

Parameters

actx	Attachment context
aa	Selected attachments

Return values

ptr	Parent attachment
NULL	No parent exists

Definition at line 328 of file recvcmd.c.

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

Here is the call graph for this function:

Here is the caller graph for this function:

include_header()

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 364 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_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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

copy_problematic_attachments()

struct Body ** copy_problematic_attachments ( struct Body ** last, struct AttachPtrArray * aa, bool force )

static

Attach the body parts which can't be decoded.

Parameters

[out]	last	Body pointer to update
[in]	aa	Selected attachments
[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 410 of file recvcmd.c.

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

Here is the call graph for this function:

Here is the caller graph for this function:

attach_forward_bodies()

void attach_forward_bodies ( struct Email * e, struct AttachCtx * actx, struct AttachPtrArray * aa )

static

Forward one or several MIME bodies.

Parameters

e	Email
actx	Attachment Context
aa	Selected attachments

(non-message types)

Definition at line 434 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();
  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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

attach_forward_msgs()

void attach_forward_msgs ( struct AttachPtrArray * aa, SendFlags flags )

static

Forward one or several message-type attachments.

Parameters

aa	Selected attachments
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 621 of file recvcmd.c.

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

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_attach_forward()

void mutt_attach_forward	(	struct AttachPtrArray *	aa,
		struct Email *	e,
		struct AttachCtx *	actx,
		SendFlags	flags )

Forward selected attachments.

Parameters

aa	Selected attachments
e	Email
actx	Attachment Context
flags	Send mode, see SendFlags

Definition at line 737 of file recvcmd.c.

{
  if (check_all_msg(aa, false))
  {
    attach_forward_msgs(aa, flags);
  }
  else
  {
    attach_forward_bodies(e, actx, aa);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

attach_reply_envelope_defaults()

int attach_reply_envelope_defaults ( struct Envelope * env, struct AttachPtrArray * aa, struct Email * parent, SendFlags flags )

static

Create the envelope defaults for a reply.

Parameters

env	Envelope to fill in
aa	Selected attachments
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 selected bodies are of a message type, and the header information is fetched from them.

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

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

Definition at line 769 of file recvcmd.c.

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

Here is the call graph for this function:

Here is the caller graph for this function:

attach_include_reply()

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 856 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	(	struct AttachPtrArray *	aa,
		struct Mailbox *	m,
		struct Email *	e,
		struct AttachCtx *	actx,
		SendFlags	flags )

Attach a reply.

Parameters

aa	Selected attachments
m	Mailbox
e	Email
actx	Attachment Context
flags	Send mode, see SendFlags

Definition at line 885 of file recvcmd.c.

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

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 AttachPtrArray *

aa

)

Compose an email to the sender in the email attachment.

Parameters

aa	Selected attachments

Definition at line 1074 of file recvcmd.c.

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

Here is the call graph for this function:

Here is the caller graph for this function: