send.h File Reference

Prepare and send an email. More...

#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>

Include dependency graph for send.h:

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

Go to the source code of this file.

Macros
#define	SEND_NO_FLAGS   0
	No flags are set.
#define	SEND_REPLY   (1 << 0)
	Reply to sender.
#define	SEND_GROUP_REPLY   (1 << 1)
	Reply to all.
#define	SEND_LIST_REPLY   (1 << 2)
	Reply to mailing list.
#define	SEND_FORWARD   (1 << 3)
	Forward email.
#define	SEND_POSTPONED   (1 << 4)
	Recall a postponed email.
#define	SEND_BATCH   (1 << 5)
	Send email in batch mode (without user interaction)
#define	SEND_KEY   (1 << 6)
	Mail a PGP public key.
#define	SEND_RESEND   (1 << 7)
	Reply using the current email as a template.
#define	SEND_POSTPONED_FCC   (1 << 8)
	Used by mutt_get_postponed() to signal that the Mutt-Fcc header field was present.
#define	SEND_NO_FREE_HEADER   (1 << 9)
	Used by the -E flag.
#define	SEND_DRAFT_FILE   (1 << 10)
	Used by the -H flag.
#define	SEND_TO_SENDER   (1 << 11)
	Compose new email to sender.
#define	SEND_GROUP_CHAT_REPLY   (1 << 12)
	Reply to all recipients preserving To/Cc.
#define	SEND_NEWS   (1 << 13)
	Reply to a news article.
#define	SEND_REVIEW_TO   (1 << 14)
	Allow the user to edit the To field.
#define	SEND_CONSUMED_STDIN   (1 << 15)
	stdin has been read; don't read it twice
#define	SEND_CLI_CRYPTO   (1 << 16)
	Enable message security in modes that by default don't enable it.

Typedefs
typedef uint32_t	SendFlags
	Flags for mutt_send_message(), e.g. SEND_REPLY.

Functions
void	mutt_add_to_reference_headers (struct Envelope *env, struct Envelope *env_cur, struct ConfigSubset *sub)
	Generate references for a reply email.
struct Address *	mutt_default_from (struct ConfigSubset *sub)
	Get a default 'from' Address.
int	mutt_edit_address (struct AddressList *al, const char *field, bool expand_aliases)
	Edit an email address.
void	mutt_encode_descriptions (struct Body *b, bool recurse, struct ConfigSubset *sub)
	RFC2047 encode the content-descriptions.
int	mutt_fetch_recips (struct Envelope *out, struct Envelope *in, SendFlags flags, struct ConfigSubset *sub)
	Generate recpients for a reply email.
void	mutt_fix_reply_recipients (struct Envelope *env, struct ConfigSubset *sub)
	Remove duplicate recipients.
void	mutt_forward_intro (struct Email *e, FILE *fp, struct ConfigSubset *sub)
	Add the "start of forwarded message" text.
void	mutt_forward_trailer (struct Email *e, FILE *fp, struct ConfigSubset *sub)
	Add a "end of forwarded message" text.
void	mutt_make_attribution_intro (struct Email *e, FILE *fp_out, struct ConfigSubset *sub)
	Add "on DATE, PERSON wrote" header.
void	mutt_make_attribution_trailer (struct Email *e, FILE *fp_out, struct ConfigSubset *sub)
	Add suffix to replied email text.
void	mutt_make_forward_subject (struct Envelope *env, struct Email *e, struct ConfigSubset *sub)
	Create a subject for a forwarded email.
void	mutt_make_misc_reply_headers (struct Envelope *env, struct Envelope *env_cur, struct ConfigSubset *sub)
	Set subject for a reply.
int	mutt_resend_message (FILE *fp, struct Mailbox *m, struct Email *e_cur, struct ConfigSubset *sub)
	Resend an email.
int	mutt_send_message (SendFlags flags, struct Email *e_templ, const char *tempfile, struct Mailbox *m, struct EmailArray *ea, struct ConfigSubset *sub)
	Send an email.
void	mutt_set_followup_to (struct Envelope *env, struct ConfigSubset *sub)
	Set followup-to field.
bool	mutt_send_list_subscribe (struct Mailbox *m, struct Email *e)
	Send a mailing-list subscription email.
bool	mutt_send_list_unsubscribe (struct Mailbox *m, struct Email *e)
	Send a mailing-list unsubscription email.

Detailed Description

Prepare and send an email.

Authors

• Richard Russon
• Pietro Cerutti
• Alejandro Colomar

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

Macro Definition Documentation

SEND_NO_FLAGS

#define SEND_NO_FLAGS   0

No flags are set.

Definition at line 41 of file send.h.

SEND_REPLY

#define SEND_REPLY   (1 << 0)

Reply to sender.

Definition at line 42 of file send.h.

SEND_GROUP_REPLY

#define SEND_GROUP_REPLY   (1 << 1)

Reply to all.

Definition at line 43 of file send.h.

SEND_LIST_REPLY

#define SEND_LIST_REPLY   (1 << 2)

Reply to mailing list.

Definition at line 44 of file send.h.

SEND_FORWARD

#define SEND_FORWARD   (1 << 3)

Forward email.

Definition at line 45 of file send.h.

SEND_POSTPONED

#define SEND_POSTPONED   (1 << 4)

Recall a postponed email.

Definition at line 46 of file send.h.

SEND_BATCH

#define SEND_BATCH   (1 << 5)

Send email in batch mode (without user interaction)

Definition at line 47 of file send.h.

SEND_KEY

#define SEND_KEY   (1 << 6)

Mail a PGP public key.

Definition at line 48 of file send.h.

SEND_RESEND

#define SEND_RESEND   (1 << 7)

Reply using the current email as a template.

Definition at line 49 of file send.h.

SEND_POSTPONED_FCC

#define SEND_POSTPONED_FCC   (1 << 8)

Used by mutt_get_postponed() to signal that the Mutt-Fcc header field was present.

Definition at line 50 of file send.h.

SEND_NO_FREE_HEADER

#define SEND_NO_FREE_HEADER   (1 << 9)

Used by the -E flag.

Definition at line 51 of file send.h.

SEND_DRAFT_FILE

#define SEND_DRAFT_FILE   (1 << 10)

Used by the -H flag.

Definition at line 52 of file send.h.

SEND_TO_SENDER

#define SEND_TO_SENDER   (1 << 11)

Compose new email to sender.

Definition at line 53 of file send.h.

SEND_GROUP_CHAT_REPLY

#define SEND_GROUP_CHAT_REPLY   (1 << 12)

Reply to all recipients preserving To/Cc.

Definition at line 54 of file send.h.

SEND_NEWS

#define SEND_NEWS   (1 << 13)

Reply to a news article.

Definition at line 55 of file send.h.

SEND_REVIEW_TO

#define SEND_REVIEW_TO   (1 << 14)

Allow the user to edit the To field.

Definition at line 56 of file send.h.

SEND_CONSUMED_STDIN

#define SEND_CONSUMED_STDIN   (1 << 15)

stdin has been read; don't read it twice

Definition at line 57 of file send.h.

SEND_CLI_CRYPTO

#define SEND_CLI_CRYPTO   (1 << 16)

Enable message security in modes that by default don't enable it.

Definition at line 58 of file send.h.

Typedef Documentation

SendFlags

typedef uint32_t SendFlags

Flags for mutt_send_message(), e.g. SEND_REPLY.

Definition at line 40 of file send.h.

Function Documentation

mutt_add_to_reference_headers()

void mutt_add_to_reference_headers	(	struct Envelope *	env,
		struct Envelope *	env_cur,
		struct ConfigSubset *	sub
	)

Generate references for a reply email.

Parameters

env	Envelope for result
env_cur	Envelope of source email
sub	Config Subset

Definition at line 1097 of file send.c.

{
  add_references(&env->references, env_cur);
  add_message_id(&env->references, env_cur);
  add_message_id(&env->in_reply_to, env_cur);
 
  const bool c_x_comment_to = cs_subset_bool(sub, "x_comment_to");
  if (OptNewsSend && c_x_comment_to && !TAILQ_EMPTY(&env_cur->from))
    env->x_comment_to = mutt_str_dup(mutt_get_name(TAILQ_FIRST(&env_cur->from)));
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_default_from()

struct Address * mutt_default_from

(

struct ConfigSubset *

sub

)

Get a default 'from' Address.

Parameters

sub	Config Subset

Return values

ptr	Newly allocated Address

Definition at line 1458 of file send.c.

{
  /* Note: We let $from override $real_name here.
   *       Is this the right thing to do?
   */
 
  const struct Address *c_from = cs_subset_address(sub, "from");
  if (c_from)
  {
    return mutt_addr_copy(c_from);
  }
 
  char domain[1024] = { 0 };
  const char *mailbox = Username;
  const bool c_use_domain = cs_subset_bool(sub, "use_domain");
  if (c_use_domain)
  {
    snprintf(domain, sizeof(domain), "%s@%s", NONULL(Username),
             NONULL(mutt_fqdn(true, sub)));
    mailbox = domain;
  }
 
  return mutt_addr_create(NULL, mailbox);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_edit_address()

int mutt_edit_address	(	struct AddressList *	al,
		const char *	field,
		bool	expand_aliases
	)

Edit an email address.

Parameters

[in,out]	al	AddressList to edit
[in]	field	Prompt for user
[in]	expand_aliases	If true, expand Address aliases

Return values

0	Success
-1	Failure

Definition at line 191 of file send.c.

{
  int rc = 0;
  struct Buffer *buf = buf_pool_get();
  buf_alloc(buf, 8192);
  char *err = NULL;
  int idna_ok = 0;
 
  do
  {
    mutt_addrlist_to_local(al);
    buf_reset(buf);
    mutt_addrlist_write(al, buf, false);
    if (mw_get_field(field, buf, MUTT_COMP_NO_FLAGS, HC_ALIAS, &CompleteAliasOps, NULL) != 0)
    {
      rc = -1;
      goto done;
    }
    mutt_addrlist_clear(al);
    mutt_addrlist_parse2(al, buf_string(buf));
    if (expand_aliases)
      mutt_expand_aliases(al);
    idna_ok = mutt_addrlist_to_intl(al, &err);
    if (idna_ok != 0)
    {
      mutt_error(_("Bad IDN: '%s'"), err);
      FREE(&err);
    }
  } while (idna_ok != 0);
 
done:
  buf_pool_release(&buf);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_encode_descriptions()

void mutt_encode_descriptions	(	struct Body *	b,
		bool	recurse,
		struct ConfigSubset *	sub
	)

RFC2047 encode the content-descriptions.

Parameters

b	Body of email
recurse	If true, encode children parts
sub	Config Subset

Definition at line 1554 of file send.c.

{
  const struct Slist *const c_send_charset = cs_subset_slist(sub, "send_charset");
  for (struct Body *t = b; t; t = t->next)
  {
    if (t->description)
    {
      rfc2047_encode(&t->description, NULL, sizeof("Content-Description:"), c_send_charset);
    }
    if (recurse && t->parts)
      mutt_encode_descriptions(t->parts, recurse, sub);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_fetch_recips()

int mutt_fetch_recips	(	struct Envelope *	out,
		struct Envelope *	in,
		SendFlags	flags,
		struct ConfigSubset *	sub
	)

Generate recpients for a reply email.

Parameters

out	Envelope to populate
in	Envelope of source email
flags	Flags, see SendFlags
sub	Config Subset

Return values

0	Success
-1	Failure

Definition at line 936 of file send.c.

{
  enum QuadOption hmfupto = MUTT_ABORT;
  const struct Address *followup_to = TAILQ_FIRST(&in->mail_followup_to);
 
  if ((flags & (SEND_LIST_REPLY | SEND_GROUP_REPLY | SEND_GROUP_CHAT_REPLY)) && followup_to)
  {
    char prompt[256] = { 0 };
    snprintf(prompt, sizeof(prompt), _("Follow-up to %s%s?"),
             buf_string(followup_to->mailbox),
             TAILQ_NEXT(TAILQ_FIRST(&in->mail_followup_to), entries) ? ",..." : "");
 
    hmfupto = query_quadoption(prompt, sub, "honor_followup_to");
    if (hmfupto == MUTT_ABORT)
      return -1;
  }
 
  if (flags & SEND_LIST_REPLY)
  {
    add_mailing_lists(&out->to, &in->to, &in->cc);
 
    if (followup_to && (hmfupto == MUTT_YES) &&
        (default_to(&out->cc, in, flags & SEND_LIST_REPLY, (hmfupto == MUTT_YES), sub) == MUTT_ABORT))
    {
      return -1; /* abort */
    }
  }
  else if (flags & SEND_TO_SENDER)
  {
    mutt_addrlist_copy(&out->to, &in->from, false);
  }
  else
  {
    if (default_to(&out->to, in, flags & (SEND_GROUP_REPLY | SEND_GROUP_CHAT_REPLY),
                   (hmfupto == MUTT_YES), sub) == -1)
    {
      return -1; /* abort */
    }
 
    if ((flags & (SEND_GROUP_REPLY | SEND_GROUP_CHAT_REPLY)) &&
        (!followup_to || (hmfupto != MUTT_YES)))
    {
      /* if(!mutt_addr_is_user(in->to)) */
      if (flags & SEND_GROUP_REPLY)
        mutt_addrlist_copy(&out->cc, &in->to, true);
      else
        mutt_addrlist_copy(&out->to, &in->to, true);
      mutt_addrlist_copy(&out->cc, &in->cc, true);
    }
  }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_fix_reply_recipients()

void mutt_fix_reply_recipients	(	struct Envelope *	env,
		struct ConfigSubset *	sub
	)

Remove duplicate recipients.

Parameters

env	Envelope to fix
sub	Config Subset

Definition at line 1019 of file send.c.

{
  const bool c_me_too = cs_subset_bool(sub, "me_too");
  if (!c_me_too)
  {
    const bool c_reply_self = cs_subset_bool(sub, "reply_self");
 
    /* the order is important here.  do the CC: first so that if the
     * the user is the only recipient, it ends up on the TO: field */
    remove_user(&env->cc, TAILQ_EMPTY(&env->to));
    remove_user(&env->to, TAILQ_EMPTY(&env->cc) || c_reply_self);
  }
 
  /* the CC field can get cluttered, especially with lists */
  mutt_addrlist_dedupe(&env->to);
  mutt_addrlist_dedupe(&env->cc);
  mutt_addrlist_remove_xrefs(&env->to, &env->cc);
 
  if (!TAILQ_EMPTY(&env->cc) && TAILQ_EMPTY(&env->to))
  {
    TAILQ_SWAP(&env->to, &env->cc, Address, entries);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_forward_intro()

void mutt_forward_intro	(	struct Email *	e,
		FILE *	fp,
		struct ConfigSubset *	sub
	)

Add the "start of forwarded message" text.

Parameters

e	Email
sub	Config Subset
fp	File to write to

Definition at line 452 of file send.c.

{
  const struct Expando *c_forward_attribution_intro = cs_subset_expando(sub, "forward_attribution_intro");
  if (!c_forward_attribution_intro || !fp)
    return;
 
  const char *const c_attribution_locale = cs_subset_string(sub, "attribution_locale");
 
  struct Buffer *buf = buf_pool_get();
  setlocale(LC_TIME, NONULL(c_attribution_locale));
  mutt_make_string(buf, -1, c_forward_attribution_intro, NULL, -1, e,
                   MUTT_FORMAT_NO_FLAGS, NULL);
  setlocale(LC_TIME, "");
  fputs(buf_string(buf), fp);
  fputs("\n\n", fp);
  buf_pool_release(&buf);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_forward_trailer()

void mutt_forward_trailer	(	struct Email *	e,
		FILE *	fp,
		struct ConfigSubset *	sub
	)

Add a "end of forwarded message" text.

Parameters

e	Email
sub	Config Subset
fp	File to write to

Definition at line 476 of file send.c.

{
  const struct Expando *c_forward_attribution_trailer = cs_subset_expando(sub, "forward_attribution_trailer");
  if (!c_forward_attribution_trailer || !fp)
    return;
 
  const char *const c_attribution_locale = cs_subset_string(sub, "attribution_locale");
 
  struct Buffer *buf = buf_pool_get();
  setlocale(LC_TIME, NONULL(c_attribution_locale));
  mutt_make_string(buf, -1, c_forward_attribution_trailer, NULL, -1, e,
                   MUTT_FORMAT_NO_FLAGS, NULL);
  setlocale(LC_TIME, "");
  fputc('\n', fp);
  fputs(buf_string(buf), fp);
  fputc('\n', fp);
  buf_pool_release(&buf);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_make_attribution_intro()

void mutt_make_attribution_intro	(	struct Email *	e,
		FILE *	fp_out,
		struct ConfigSubset *	sub
	)

Add "on DATE, PERSON wrote" header.

Parameters

e	Email
fp_out	File to write to
sub	Config Subset

Definition at line 660 of file send.c.

{
  format_attribution(cs_subset_expando(sub, "attribution_intro"), e, fp_out, sub);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_make_attribution_trailer()

void mutt_make_attribution_trailer	(	struct Email *	e,
		FILE *	fp_out,
		struct ConfigSubset *	sub
	)

Add suffix to replied email text.

Parameters

e	Email
fp_out	File to write to
sub	Config Subset

Definition at line 671 of file send.c.

{
  format_attribution(cs_subset_expando(sub, "attribution_trailer"), e, fp_out, sub);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_make_forward_subject()

void mutt_make_forward_subject	(	struct Envelope *	env,
		struct Email *	e,
		struct ConfigSubset *	sub
	)

Create a subject for a forwarded email.

Parameters

env	Envelope for result
e	Email
sub	Config Subset

Definition at line 1049 of file send.c.

{
  if (!env)
    return;
 
  const struct Expando *c_forward_format = cs_subset_expando(sub, "forward_format");
 
  struct Buffer *buf = buf_pool_get();
  /* set the default subject for the message. */
  mutt_make_string(buf, -1, c_forward_format, NULL, -1, e, MUTT_FORMAT_NO_FLAGS, NULL);
  mutt_env_set_subject(env, buf_string(buf));
  buf_pool_release(&buf);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_make_misc_reply_headers()

void mutt_make_misc_reply_headers	(	struct Envelope *	env,
		struct Envelope *	env_cur,
		struct ConfigSubset *	sub
	)

Set subject for a reply.

Parameters

env	Envelope for result
env_cur	Envelope of source email
sub	Config Subset

Definition at line 1069 of file send.c.

{
  if (!env || !env_cur)
    return;
 
  /* This takes precedence over a subject that might have
   * been taken from a List-Post header.  Is that correct?  */
  if (env_cur->real_subj)
  {
    char *subj = NULL;
    mutt_str_asprintf(&subj, "Re: %s", env_cur->real_subj);
    mutt_env_set_subject(env, subj);
    FREE(&subj);
  }
  else if (!env->subject)
  {
    const char *const c_empty_subject = cs_subset_string(sub, "empty_subject");
    mutt_env_set_subject(env, c_empty_subject);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_resend_message()

int mutt_resend_message	(	FILE *	fp,
		struct Mailbox *	m,
		struct Email *	e_cur,
		struct ConfigSubset *	sub
	)

Resend an email.

Parameters

fp	File containing email
m	Mailbox
e_cur	Email to resend
sub	Config Subset

Return values

0	Message was successfully sent
-1	Message was aborted or an error occurred
1	Message was postponed

Definition at line 1614 of file send.c.

{
  struct Email *e_new = email_new();
 
  if (mutt_prepare_template(fp, m, e_new, e_cur, true) < 0)
  {
    email_free(&e_new);
    return -1;
  }
 
  if (WithCrypto)
  {
    /* mutt_prepare_template doesn't always flip on an application bit.
     * so fix that here */
    if (!(e_new->security & (APPLICATION_SMIME | APPLICATION_PGP)))
    {
      const bool c_smime_is_default = cs_subset_bool(sub, "smime_is_default");
      if (((WithCrypto & APPLICATION_SMIME) != 0) && c_smime_is_default)
        e_new->security |= APPLICATION_SMIME;
      else if (WithCrypto & APPLICATION_PGP)
        e_new->security |= APPLICATION_PGP;
      else
        e_new->security |= APPLICATION_SMIME;
    }
 
    const bool c_crypt_opportunistic_encrypt = cs_subset_bool(sub, "crypt_opportunistic_encrypt");
    if (c_crypt_opportunistic_encrypt)
    {
      e_new->security |= SEC_OPPENCRYPT;
      crypt_opportunistic_encrypt(e_new);
    }
  }
 
  struct EmailArray ea = ARRAY_HEAD_INITIALIZER;
  ARRAY_ADD(&ea, e_cur);
  int rc = mutt_send_message(SEND_RESEND, e_new, NULL, m, &ea, sub);
  ARRAY_FREE(&ea);
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_send_message()

int mutt_send_message	(	SendFlags	flags,
		struct Email *	e_templ,
		const char *	tempfile,
		struct Mailbox *	m,
		struct EmailArray *	ea,
		struct ConfigSubset *	sub
	)

Send an email.

Parameters

flags	Send mode, see SendFlags
e_templ	Template to use for new message
tempfile	File specified by -i or -H
m	Current mailbox
ea	Array of Emails to send
sub	Config Subset

Return values

0	Message was successfully sent
-1	Message was aborted or an error occurred
1	Message was postponed

Definition at line 2099 of file send.c.

{
  struct Buffer *fcc = buf_pool_get(); /* where to copy this message */
  FILE *fp_tmp = NULL;
  struct Body *pbody = NULL;
  int i;
  bool free_clear_content = false;
 
  struct Body *clear_content = NULL;
  char *pgpkeylist = NULL;
  /* save current value of "pgp_sign_as"  and "smime_default_key" */
  char *pgp_sign_as = NULL;
  char *smime_sign_as = NULL;
  const char *tag = NULL;
  char *err = NULL;
  const char *ctype = NULL;
  char *finalpath = NULL;
  struct Email *e_cur = NULL;
 
  if (ea && (ARRAY_SIZE(ea) == 1))
    e_cur = *ARRAY_GET(ea, 0);
 
  int rc = -1;
 
  if (flags & SEND_NEWS)
    OptNewsSend = true;
  else
    OptNewsSend = false;
 
  const enum QuadOption c_recall = cs_subset_quad(sub, "recall");
 
  if (!flags && !e_templ && (c_recall != MUTT_NO) && mutt_num_postponed(m, true))
  {
    /* If the user is composing a new message, check to see if there
     * are any postponed messages first.  */
    enum QuadOption ans = query_quadoption(_("Recall postponed message?"), sub, "recall");
    if (ans == MUTT_ABORT)
      return rc;
 
    if (ans == MUTT_YES)
      flags |= SEND_POSTPONED;
  }
 
  if (flags & SEND_POSTPONED)
  {
    if (WithCrypto & APPLICATION_PGP)
    {
      const char *const c_pgp_sign_as = cs_subset_string(sub, "pgp_sign_as");
      pgp_sign_as = mutt_str_dup(c_pgp_sign_as);
    }
    if (WithCrypto & APPLICATION_SMIME)
    {
      const char *const c_smime_sign_as = cs_subset_string(sub, "smime_sign_as");
      smime_sign_as = mutt_str_dup(c_smime_sign_as);
    }
  }
 
  /* Delay expansion of aliases until absolutely necessary--shouldn't
   * be necessary unless we are prompting the user or about to execute a
   * send-hook.  */
 
  if (!e_templ)
  {
    e_templ = email_new();
 
    if (flags == SEND_POSTPONED)
    {
      rc = mutt_get_postponed(m, e_templ, &e_cur, fcc);
      if (rc < 0)
      {
        flags = SEND_POSTPONED;
        goto cleanup;
      }
      flags = rc;
      /* If postponed message is a news article, it have
       * a "Newsgroups:" header line, then set appropriate flag.  */
      if (e_templ->env->newsgroups)
      {
        flags |= SEND_NEWS;
        OptNewsSend = true;
      }
      else
      {
        flags &= ~SEND_NEWS;
        OptNewsSend = false;
      }
    }
 
    if (flags & (SEND_POSTPONED | SEND_RESEND))
    {
      struct Body *b = e_templ->body;
      while (b->parts)
        b = b->parts;
      fp_tmp = mutt_file_fopen(b->filename, "a+");
      if (!fp_tmp)
      {
        mutt_perror("%s", b->filename);
        goto cleanup;
      }
    }
 
    if (!e_templ->env)
      e_templ->env = mutt_env_new();
  }
 
  /* Parse and use an eventual list-post header */
  if ((flags & SEND_LIST_REPLY) && e_cur && e_cur->env && e_cur->env->list_post)
  {
    /* Use any list-post header as a template */
    mutt_parse_mailto(e_templ->env, NULL, e_cur->env->list_post);
    /* We don't let them set the sender's address. */
    mutt_addrlist_clear(&e_templ->env->from);
  }
 
  if (!(flags & (SEND_KEY | SEND_POSTPONED | SEND_RESEND)))
  {
    /* When SEND_DRAFT_FILE is set, the caller has already
     * created the "parent" body structure.  */
    if (!(flags & SEND_DRAFT_FILE))
    {
      pbody = mutt_body_new();
      pbody->next = e_templ->body; /* don't kill command-line attachments */
      e_templ->body = pbody;
 
      const char *const c_content_type = cs_subset_string(sub, "content_type");
      ctype = c_content_type;
      if (!ctype)
        ctype = "text/plain";
      mutt_parse_content_type(ctype, e_templ->body);
      e_templ->body->unlink = true;
      e_templ->body->use_disp = false;
      e_templ->body->disposition = DISP_INLINE;
 
      if (tempfile)
      {
        fp_tmp = mutt_file_fopen(tempfile, "a+");
        e_templ->body->filename = mutt_str_dup(tempfile);
        if (flags & SEND_NO_FREE_HEADER)
          e_templ->body->unlink = false;
      }
      else
      {
        struct Buffer *buf = buf_pool_get();
        buf_mktemp(buf);
        fp_tmp = mutt_file_fopen(buf_string(buf), "w+");
        e_templ->body->filename = buf_strdup(buf);
        buf_pool_release(&buf);
      }
    }
    else
    {
      struct Body *b = e_templ->body;
      while (b->parts)
        b = b->parts;
      fp_tmp = mutt_file_fopen(b->filename, "a+");
    }
 
    if (!fp_tmp)
    {
      mutt_debug(LL_DEBUG1, "can't create tempfile %s (errno=%d)\n",
                 e_templ->body->filename, errno);
      mutt_perror("%s", e_templ->body->filename);
      goto cleanup;
    }
  }
 
  const bool c_reverse_name = cs_subset_bool(sub, "reverse_name");
  /* this is handled here so that the user can match ~f in send-hook */
  if (e_cur && c_reverse_name && !(flags & (SEND_POSTPONED | SEND_RESEND)))
  {
    /* We shouldn't have to worry about alias expansion here since we are
     * either replying to a real or postponed message, therefore no aliases
     * should exist since the user has not had the opportunity to add
     * addresses to the list.  We just have to ensure the postponed messages
     * have their aliases expanded.  */
 
    if (!TAILQ_EMPTY(&e_templ->env->from))
    {
      mutt_debug(LL_DEBUG5, "e_templ->env->from before set_reverse_name: %s\n",
                 buf_string(TAILQ_FIRST(&e_templ->env->from)->mailbox));
      mutt_addrlist_clear(&e_templ->env->from);
    }
    set_reverse_name(&e_templ->env->from, e_cur->env, sub);
  }
 
  const bool c_reply_with_xorig = cs_subset_bool(sub, "reply_with_xorig");
  if (e_cur && c_reply_with_xorig && !(flags & (SEND_POSTPONED | SEND_RESEND | SEND_FORWARD)))
  {
    /* We shouldn't have to worry about freeing 'e_templ->env->from' before
     * setting it here since this code will only execute when doing some
     * sort of reply. The pointer will only be set when using the -H command
     * line option.
     *
     * If there is already a from address recorded in 'e_templ->env->from',
     * then it theoretically comes from `$reverse_name` handling, and we don't use
     * the 'X-Original-To header'.  */
    if (!TAILQ_EMPTY(&e_cur->env->x_original_to) && TAILQ_EMPTY(&e_templ->env->from))
    {
      mutt_addrlist_copy(&e_templ->env->from, &e_cur->env->x_original_to, false);
      mutt_debug(LL_DEBUG5, "e_templ->env->from extracted from X-Original-To: header: %s\n",
                 buf_string(TAILQ_FIRST(&e_templ->env->from)->mailbox));
    }
  }
 
  const bool c_resume_draft_files = cs_subset_bool(sub, "resume_draft_files");
  if (!(flags & (SEND_POSTPONED | SEND_RESEND)) &&
      !((flags & SEND_DRAFT_FILE) && c_resume_draft_files))
  {
    if ((flags & (SEND_REPLY | SEND_FORWARD | SEND_TO_SENDER)) &&
        (envelope_defaults(e_templ->env, ea, flags, sub) == -1))
    {
      goto cleanup;
    }
 
    const bool c_hdrs = cs_subset_bool(sub, "hdrs");
    if (c_hdrs)
      process_user_recips(e_templ->env);
 
    /* Expand aliases and remove duplicates/crossrefs */
    mutt_expand_aliases_env(e_templ->env);
 
    if (flags & SEND_REPLY)
      mutt_fix_reply_recipients(e_templ->env, sub);
 
    if ((flags & SEND_NEWS) && (m && m->type == MUTT_NNTP) && !e_templ->env->newsgroups)
    {
      e_templ->env->newsgroups = mutt_str_dup(((struct NntpMboxData *) m->mdata)->group);
    }
 
    const bool c_auto_edit = cs_subset_bool(sub, "auto_edit");
    const bool c_edit_headers = cs_subset_bool(sub, "edit_headers");
    const bool c_fast_reply = cs_subset_bool(sub, "fast_reply");
    if (!(flags & SEND_BATCH) && !(c_auto_edit && c_edit_headers) &&
        !((flags & SEND_REPLY) && c_fast_reply))
    {
      if (edit_envelope(e_templ->env, flags, sub) == -1)
        goto cleanup;
    }
 
    /* the from address must be set here regardless of whether or not
     * $use_from is set so that the '~P' (from you) operator in send-hook
     * patterns will work.  if $use_from is unset, the from address is killed
     * after send-hooks are evaluated */
 
    const bool killfrom = TAILQ_EMPTY(&e_templ->env->from);
    if (killfrom)
    {
      mutt_addrlist_append(&e_templ->env->from, mutt_default_from(sub));
    }
 
    if ((flags & SEND_REPLY) && e_cur)
    {
      /* change setting based upon message we are replying to */
      mutt_message_hook(m, e_cur, MUTT_REPLY_HOOK);
 
      /* set the replied flag for the message we are generating so that the
       * user can use ~Q in a send-hook to know when reply-hook's are also
       * being used.  */
      e_templ->replied = true;
    }
 
    /* change settings based upon recipients */
 
    mutt_message_hook(NULL, e_templ, MUTT_SEND_HOOK);
 
    /* Unset the replied flag from the message we are composing since it is
     * no longer required.  This is done here because the FCC'd copy of
     * this message was erroneously get the 'R'eplied flag when stored in
     * a maildir-style mailbox.  */
    e_templ->replied = false;
 
    /* $use_from and/or $from might have changed in a send-hook */
    if (killfrom)
    {
      mutt_addrlist_clear(&e_templ->env->from);
 
      const bool c_use_from = cs_subset_bool(sub, "use_from");
      if (c_use_from && !(flags & (SEND_POSTPONED | SEND_RESEND)))
        mutt_addrlist_append(&e_templ->env->from, mutt_default_from(sub));
    }
 
    if (c_hdrs)
      process_user_header(e_templ->env);
 
    if ((flags & SEND_BATCH) && !(flags & SEND_CONSUMED_STDIN))
    {
      if (mutt_file_copy_stream(stdin, fp_tmp) < 0)
      {
        mutt_error(_("Error sending message"));
        goto cleanup;
      }
    }
 
    if (!(flags & SEND_BATCH))
      mutt_make_greeting(e_templ, fp_tmp, sub);
 
    const bool c_sig_on_top = cs_subset_bool(sub, "sig_on_top");
    const char *const c_editor = cs_subset_string(sub, "editor");
    if (c_sig_on_top && !(flags & (SEND_KEY | SEND_BATCH)) && c_editor)
    {
      append_signature(fp_tmp, sub);
    }
 
    /* include replies/forwarded messages, unless we are given a template */
    if (!tempfile && (m || !(flags & (SEND_REPLY | SEND_FORWARD))) &&
        (generate_body(fp_tmp, e_templ, flags, m, ea, sub) == -1))
    {
      goto cleanup;
    }
 
    if (!c_sig_on_top && !(flags & (SEND_KEY | SEND_BATCH)) && c_editor)
    {
      append_signature(fp_tmp, sub);
    }
  }
 
  /* Only set format=flowed for new messages.  postponed/resent/draftfiles
   * should respect the original email.
   *
   * This is set here so that send-hook can be used to turn the option on.  */
  if (!(flags & (SEND_KEY | SEND_POSTPONED | SEND_RESEND | SEND_DRAFT_FILE)))
  {
    const bool c_text_flowed = cs_subset_bool(sub, "text_flowed");
    if (c_text_flowed && is_text_plain(e_templ->body))
    {
      mutt_param_set(&e_templ->body->parameter, "format", "flowed");
    }
  }
 
  /* This hook is even called for postponed messages, and can, e.g., be used
   * for setting the editor, the sendmail path, or the envelope sender.  */
  mutt_message_hook(NULL, e_templ, MUTT_SEND2_HOOK);
 
  /* wait until now to set the real name portion of our return address so
   * that $real_name can be set in a send-hook */
  {
    struct Address *from = TAILQ_FIRST(&e_templ->env->from);
    if (from && !from->personal && !(flags & (SEND_RESEND | SEND_POSTPONED)))
    {
      const char *const c_real_name = cs_subset_string(sub, "real_name");
      if (c_real_name)
        from->personal = buf_new(c_real_name);
    }
  }
 
  if (!(((WithCrypto & APPLICATION_PGP) != 0) && (flags & SEND_KEY)))
    mutt_file_fclose(&fp_tmp);
 
  if (!(flags & SEND_BATCH))
  {
    struct stat st = { 0 };
    time_t mtime;
    struct Body *b = e_templ->body;
    while (b->parts)
      b = b->parts;
    mtime = mutt_file_decrease_mtime(b->filename, NULL);
    if (mtime == (time_t) -1)
    {
      mutt_perror("%s", b->filename);
      goto cleanup;
    }
 
    mutt_update_encoding(b, sub);
 
    const bool c_edit_headers = cs_subset_bool(sub, "edit_headers");
    const bool c_auto_edit = cs_subset_bool(sub, "auto_edit");
 
    /* Select whether or not the user's editor should be called now.  We
     * don't want to do this when:
     * 1) we are sending a key/cert
     * 2) we are forwarding a message and the user doesn't want to edit it.
     *    This is controlled by the quadoption $forward_edit.  However, if
     *    both $edit_headers and $auto_edit are set, we want to ignore the
     *    setting of $forward_edit because the user probably needs to add the
     *    recipients.  */
    if (!(flags & SEND_KEY) &&
        (((flags & SEND_FORWARD) == 0) || (c_edit_headers && c_auto_edit) ||
         (query_quadoption(_("Edit forwarded message?"), sub, "forward_edit") == MUTT_YES)))
    {
      /* If the this isn't a text message, look for a mailcap edit command */
      const char *const c_editor = cs_subset_string(sub, "editor");
      b = e_templ->body;
      while (b->parts)
        b = b->parts;
      if (mutt_needs_mailcap(b))
      {
        if (!mutt_edit_attachment(b))
          goto cleanup;
      }
      else if (c_edit_headers)
      {
        mutt_env_to_local(e_templ->env);
        mutt_edit_headers(c_editor, b->filename, e_templ, fcc);
        mutt_env_to_intl(e_templ->env, NULL, NULL);
      }
      else
      {
        mutt_edit_file(c_editor, b->filename);
        if (stat(b->filename, &st) == 0)
        {
          if (mtime != st.st_mtime)
            fix_end_of_file(b->filename);
        }
        else
        {
          mutt_perror("%s", b->filename);
        }
      }
 
      mutt_message_hook(NULL, e_templ, MUTT_SEND2_HOOK);
    }
 
    if (!(flags & (SEND_POSTPONED | SEND_FORWARD | SEND_KEY | SEND_RESEND | SEND_DRAFT_FILE)))
    {
      if (stat(e_templ->body->filename, &st) == 0)
      {
        /* if the file was not modified, bail out now */
        if ((mtime == st.st_mtime) && !e_templ->body->next &&
            (query_quadoption(_("Abort unmodified message?"), sub, "abort_unmodified") == MUTT_YES))
        {
          mutt_message(_("Aborted unmodified message"));
          goto cleanup;
        }
      }
      else
      {
        mutt_perror("%s", e_templ->body->filename);
      }
    }
  }
 
  /* Set the message security unless:
   * 1) crypto support is not enabled (WithCrypto==0)
   * 2) pgp: header field was present during message editing with $edit_headers (e_templ->security != 0)
   * 3) we are resending a message
   * 4) we are recalling a postponed message (don't override the user's saved settings)
   * 5) we are in batch mode
   * But 3, 4, and 5, can be overridden with '-C' in the command line (flags & SEND_CLI_CRYPTO)
   *
   * This is done after allowing the user to edit the message so that security
   * settings can be configured with send2-hook and $edit_headers.  */
  if ((WithCrypto != 0) && (e_templ->security == 0) &&
      ((flags & SEND_CLI_CRYPTO) || !(flags & (SEND_BATCH | SEND_POSTPONED | SEND_RESEND))))
  {
    bool c_autocrypt = false;
    bool c_autocrypt_reply = false;
 
#ifdef USE_AUTOCRYPT
    c_autocrypt = cs_subset_bool(sub, "autocrypt");
    c_autocrypt_reply = cs_subset_bool(sub, "autocrypt_reply");
#endif
 
    if (c_autocrypt && c_autocrypt_reply && e_cur && (e_cur->security & SEC_AUTOCRYPT))
    {
      e_templ->security |= (SEC_AUTOCRYPT | SEC_AUTOCRYPT_OVERRIDE | APPLICATION_PGP);
    }
    else
    {
      const bool c_crypt_auto_sign = cs_subset_bool(sub, "crypt_auto_sign");
      const bool c_crypt_auto_encrypt = cs_subset_bool(sub, "crypt_auto_encrypt");
      const bool c_crypt_reply_encrypt = cs_subset_bool(sub, "crypt_reply_encrypt");
      const bool c_crypt_reply_sign = cs_subset_bool(sub, "crypt_reply_sign");
      const bool c_crypt_reply_sign_encrypted = cs_subset_bool(sub, "crypt_reply_sign_encrypted");
 
      if (c_crypt_auto_sign)
        e_templ->security |= SEC_SIGN;
      if (c_crypt_auto_encrypt)
        e_templ->security |= SEC_ENCRYPT;
      if (c_crypt_reply_encrypt && e_cur && (e_cur->security & SEC_ENCRYPT))
        e_templ->security |= SEC_ENCRYPT;
      if (c_crypt_reply_sign && e_cur && (e_cur->security & SEC_SIGN))
        e_templ->security |= SEC_SIGN;
      if (c_crypt_reply_sign_encrypted && e_cur && (e_cur->security & SEC_ENCRYPT))
        e_templ->security |= SEC_SIGN;
 
      const bool c_crypt_opportunistic_encrypt = cs_subset_bool(sub, "crypt_opportunistic_encrypt");
 
      if (((WithCrypto & APPLICATION_PGP) != 0) &&
          ((e_templ->security & (SEC_ENCRYPT | SEC_SIGN)) || c_crypt_opportunistic_encrypt))
      {
        const bool c_pgp_auto_inline = cs_subset_bool(sub, "pgp_auto_inline");
        const bool c_pgp_reply_inline = cs_subset_bool(sub, "pgp_reply_inline");
 
        if (c_pgp_auto_inline)
          e_templ->security |= SEC_INLINE;
        if (c_pgp_reply_inline && e_cur && (e_cur->security & SEC_INLINE))
          e_templ->security |= SEC_INLINE;
      }
    }
 
    const bool c_crypt_opportunistic_encrypt = cs_subset_bool(sub, "crypt_opportunistic_encrypt");
 
    if (e_templ->security || c_crypt_opportunistic_encrypt)
    {
      const bool c_crypt_auto_pgp = cs_subset_bool(sub, "crypt_auto_pgp");
      const bool c_crypt_auto_smime = cs_subset_bool(sub, "crypt_auto_smime");
 
      /* When replying / forwarding, use the original message's
       * crypto system.  According to the documentation,
       * smime_is_default should be disregarded here.
       *
       * Problem: At least with forwarding, this doesn't really
       * make much sense. Should we have an option to completely
       * disable individual mechanisms at run-time?  */
      if (e_cur)
      {
        if (((WithCrypto & APPLICATION_PGP) != 0) && c_crypt_auto_pgp &&
            (e_cur->security & APPLICATION_PGP))
        {
          e_templ->security |= APPLICATION_PGP;
        }
        else if (((WithCrypto & APPLICATION_SMIME) != 0) &&
                 c_crypt_auto_smime && (e_cur->security & APPLICATION_SMIME))
        {
          e_templ->security |= APPLICATION_SMIME;
        }
      }
 
      const bool c_smime_is_default = cs_subset_bool(sub, "smime_is_default");
 
      /* No crypto mechanism selected? Use availability + smime_is_default
       * for the decision.  */
      if (!(e_templ->security & (APPLICATION_SMIME | APPLICATION_PGP)))
      {
        if (((WithCrypto & APPLICATION_SMIME) != 0) && c_crypt_auto_smime && c_smime_is_default)
        {
          e_templ->security |= APPLICATION_SMIME;
        }
        else if (((WithCrypto & APPLICATION_PGP) != 0) && c_crypt_auto_pgp)
        {
          e_templ->security |= APPLICATION_PGP;
        }
        else if (((WithCrypto & APPLICATION_SMIME) != 0) && c_crypt_auto_smime)
        {
          e_templ->security |= APPLICATION_SMIME;
        }
      }
    }
 
    /* opportunistic encrypt relies on SMIME or PGP already being selected */
    if (c_crypt_opportunistic_encrypt)
    {
      /* If something has already enabled encryption, e.g. `$crypt_auto_encrypt`
       * or `$crypt_reply_encrypt`, then don't enable opportunistic encrypt for
       * the message.  */
      if (!(e_templ->security & (SEC_ENCRYPT | SEC_AUTOCRYPT)))
      {
        e_templ->security |= SEC_OPPENCRYPT;
        crypt_opportunistic_encrypt(e_templ);
      }
    }
 
    /* No permissible mechanisms found.  Don't sign or encrypt. */
    if (!(e_templ->security & (APPLICATION_SMIME | APPLICATION_PGP)))
      e_templ->security = SEC_NO_FLAGS;
  }
 
  /* Deal with the corner case where the crypto module backend is not available.
   * This can happen if configured without PGP/SMIME and with GPGME, but
   * $crypt_use_gpgme is unset.  */
  if (e_templ->security && !crypt_has_module_backend(e_templ->security))
  {
    mutt_error(_("No crypto backend configured.  Disabling message security setting."));
    e_templ->security = SEC_NO_FLAGS;
  }
 
  /* specify a default fcc.  if we are in batchmode, only save a copy of
   * the message if the value of $copy is yes or ask-yes */
 
  const enum QuadOption c_copy = cs_subset_quad(sub, "copy");
 
  if (buf_is_empty(fcc) && !(flags & SEND_POSTPONED_FCC) &&
      (!(flags & SEND_BATCH) || (c_copy & 0x1)))
  {
    /* set the default FCC */
    const bool killfrom = TAILQ_EMPTY(&e_templ->env->from);
    if (killfrom)
    {
      mutt_addrlist_append(&e_templ->env->from, mutt_default_from(sub));
    }
    mutt_select_fcc(fcc, e_templ);
    if (killfrom)
    {
      mutt_addrlist_clear(&e_templ->env->from);
    }
  }
 
  mutt_rfc3676_space_stuff(e_templ);
 
  mutt_update_encoding(e_templ->body, sub);
 
  if (!(flags & SEND_BATCH))
  {
  main_loop:
 
    buf_pretty_mailbox(fcc);
    i = dlg_compose(e_templ, fcc,
                    ((flags & SEND_NO_FREE_HEADER) ? MUTT_COMPOSE_NOFREEHEADER : 0), sub);
    if (i == -1)
    {
      /* abort */
      if (flags & SEND_NEWS)
        mutt_message(_("Article not posted"));
      else
        mutt_message(_("Mail not sent"));
      goto cleanup;
    }
    else if (i == 1)
    {
      if (postpone_message(e_templ, e_cur, buf_string(fcc), flags, sub) != 0)
        goto main_loop;
      mutt_message(_("Message postponed"));
      rc = 1;
      goto cleanup;
    }
  }
 
  if (!(flags & SEND_NEWS))
  {
    if ((mutt_addrlist_count_recips(&e_templ->env->to) == 0) &&
        (mutt_addrlist_count_recips(&e_templ->env->cc) == 0) &&
        (mutt_addrlist_count_recips(&e_templ->env->bcc) == 0))
    {
      if (flags & SEND_BATCH)
      {
        puts(_("No recipients specified"));
        goto cleanup;
      }
 
      mutt_warning(_("No recipients specified"));
      goto main_loop;
    }
  }
 
  if (mutt_env_to_intl(e_templ->env, &tag, &err))
  {
    mutt_error(_("Bad IDN in '%s': '%s'"), tag, err);
    FREE(&err);
    if (flags & SEND_BATCH)
      goto cleanup;
    goto main_loop;
  }
 
  const enum QuadOption c_abort_nosubject = cs_subset_quad(sub, "abort_nosubject");
 
  if (!e_templ->env->subject && !(flags & SEND_BATCH) &&
      (query_quadoption(_("No subject, abort sending?"), sub, "abort_nosubject") != MUTT_NO))
  {
    /* if the abort is automatic, print an error message */
    if (c_abort_nosubject == MUTT_YES)
      mutt_error(_("No subject specified"));
    goto main_loop;
  }
 
  if ((flags & SEND_NEWS) && !e_templ->env->subject)
  {
    mutt_error(_("No subject specified"));
    goto main_loop;
  }
 
  if ((flags & SEND_NEWS) && !e_templ->env->newsgroups)
  {
    mutt_error(_("No newsgroup specified"));
    goto main_loop;
  }
 
  if (!(flags & SEND_BATCH) && abort_for_missing_attachments(e_templ->body, sub))
  {
    goto main_loop;
  }
 
  if (e_templ->body->next)
    e_templ->body = mutt_make_multipart(e_templ->body);
 
  /* Ok, we need to do it this way instead of handling all fcc stuff in
   * one place in order to avoid going to main_loop with encoded "env"
   * in case of error.  Ugh.  */
 
  mutt_encode_descriptions(e_templ->body, true, sub);
 
  /* Make sure that clear_content and free_clear_content are
   * properly initialized -- we may visit this particular place in
   * the code multiple times, including after a failed call to
   * mutt_protect().  */
 
  clear_content = NULL;
  free_clear_content = false;
 
  if (WithCrypto)
  {
    if (e_templ->security & (SEC_ENCRYPT | SEC_SIGN | SEC_AUTOCRYPT))
    {
      /* save the decrypted attachments */
      clear_content = e_templ->body;
 
      if ((crypt_get_keys(e_templ, &pgpkeylist, false) == -1) ||
          (mutt_protect(e_templ, pgpkeylist, false) == -1))
      {
        if (mutt_istr_equal(e_templ->body->subtype, "mixed"))
          e_templ->body = mutt_remove_multipart(e_templ->body);
 
        FREE(&pgpkeylist);
 
        decode_descriptions(e_templ->body);
 
        if (flags & SEND_BATCH)
        {
          mutt_message(_("Missing encryption key; mail not sent"));
          rc = -1;
          goto cleanup;
        }
 
        goto main_loop;
      }
      mutt_encode_descriptions(e_templ->body, false, sub);
    }
 
    /* at this point, e_templ->body is one of the following three things:
     * - multipart/signed.     In this case, clear_content is a child
     * - multipart/encrypted.  In this case, clear_content exists independently
     * - application/pgp.      In this case, clear_content exists independently
     * - something else.       In this case, it's the same as clear_content */
 
    /* This is ugly -- lack of "reporting back" from mutt_protect(). */
 
    if (clear_content && (e_templ->body != clear_content) &&
        (e_templ->body->parts != clear_content))
      free_clear_content = true;
  }
 
  if (!OptNoCurses)
    mutt_message(_("Sending message..."));
 
  mutt_prepare_envelope(e_templ->env, true, sub);
 
  const bool c_fcc_before_send = cs_subset_bool(sub, "fcc_before_send");
  if (c_fcc_before_send)
    save_fcc(m, e_templ, fcc, clear_content, pgpkeylist, flags, &finalpath, sub);
 
  i = invoke_mta(m, e_templ, sub);
  if (i < 0)
  {
    if (!(flags & SEND_BATCH))
    {
      if (!WithCrypto)
        ; // do nothing
      else if ((e_templ->security & (SEC_ENCRYPT | SEC_AUTOCRYPT)) ||
               ((e_templ->security & SEC_SIGN) && (e_templ->body->type == TYPE_APPLICATION)))
      {
        if (e_templ->body != clear_content)
        {
          mutt_body_free(&e_templ->body); /* destroy PGP data */
          e_templ->body = clear_content;  /* restore clear text. */
        }
      }
      else if ((e_templ->security & SEC_SIGN) && (e_templ->body->type == TYPE_MULTIPART))
      {
        mutt_body_free(&e_templ->body->parts->next); /* destroy sig */
        if (mutt_istr_equal(e_templ->body->subtype, "mixed") ||
            mutt_istr_equal(e_templ->body->subtype, "signed"))
        {
          e_templ->body = mutt_remove_multipart(e_templ->body);
        }
      }
 
      FREE(&pgpkeylist);
      mutt_env_free(&e_templ->body->mime_headers); /* protected headers */
      mutt_param_delete(&e_templ->body->parameter, "protected-headers");
      if (mutt_istr_equal(e_templ->body->subtype, "mixed"))
        e_templ->body = mutt_remove_multipart(e_templ->body);
      decode_descriptions(e_templ->body);
      mutt_unprepare_envelope(e_templ->env);
      FREE(&finalpath);
      goto main_loop;
    }
    else
    {
      puts(_("Could not send the message"));
      goto cleanup;
    }
  }
 
  if (!c_fcc_before_send)
    save_fcc(m, e_templ, fcc, clear_content, pgpkeylist, flags, &finalpath, sub);
 
  if (!OptNoCurses)
  {
    mutt_message((i != 0)            ? _("Sending in background") :
                 (flags & SEND_NEWS) ? _("Article posted") :
                                       _("Mail sent"));
#ifdef USE_NOTMUCH
    const bool c_nm_record = cs_subset_bool(sub, "nm_record");
    if (c_nm_record)
      nm_record_message(m, finalpath, e_cur);
#endif
    mutt_sleep(0);
  }
 
  if (WithCrypto)
    FREE(&pgpkeylist);
 
  if ((WithCrypto != 0) && free_clear_content)
    mutt_body_free(&clear_content);
 
  /* set 'replied' flag only if the user didn't change/remove
   * In-Reply-To: and References: headers during edit */
  if (flags & SEND_REPLY)
  {
    if (!(flags & SEND_POSTPONED) && m)
    {
      struct Email **ep = NULL;
      ARRAY_FOREACH(ep, ea)
      {
        struct Email *e = *ep;
        mutt_set_flag(m, e, MUTT_REPLIED, is_reply(e, e_templ), true);
      }
    }
  }
 
  rc = 0;
 
cleanup:
  buf_pool_release(&fcc);
 
  if (flags & SEND_POSTPONED)
  {
    if (WithCrypto & APPLICATION_PGP)
    {
      cs_subset_str_string_set(sub, "pgp_sign_as", pgp_sign_as, NULL);
      FREE(&pgp_sign_as);
    }
    if (WithCrypto & APPLICATION_SMIME)
    {
      cs_subset_str_string_set(sub, "smime_sign_as", smime_sign_as, NULL);
      FREE(&smime_sign_as);
    }
  }
 
  mutt_file_fclose(&fp_tmp);
  if (!(flags & SEND_NO_FREE_HEADER))
    email_free(&e_templ);
 
  FREE(&finalpath);
  return rc;
}

Here is the caller graph for this function:

mutt_set_followup_to()

void mutt_set_followup_to	(	struct Envelope *	env,
		struct ConfigSubset *	sub
	)

Set followup-to field.

Parameters

env	Envelope to modify
sub	Config Subset

Definition at line 1334 of file send.c.

{
  /* Only generate the Mail-Followup-To if the user has requested it, and
   * it hasn't already been set */
 
  const bool c_followup_to = cs_subset_bool(sub, "followup_to");
  if (!c_followup_to)
    return;
  if (OptNewsSend)
  {
    if (!env->followup_to && env->newsgroups && (strrchr(env->newsgroups, ',')))
      env->followup_to = mutt_str_dup(env->newsgroups);
    return;
  }
 
  if (TAILQ_EMPTY(&env->mail_followup_to))
  {
    if (mutt_is_list_recipient(false, env))
    {
      /* this message goes to known mailing lists, so create a proper
       * mail-followup-to header */
 
      mutt_addrlist_copy(&env->mail_followup_to, &env->to, false);
      mutt_addrlist_copy(&env->mail_followup_to, &env->cc, true);
    }
 
    /* remove ourselves from the mail-followup-to header */
    remove_user(&env->mail_followup_to, false);
 
    /* If we are not subscribed to any of the lists in question, re-add
     * ourselves to the mail-followup-to header.  The mail-followup-to header
     * generated is a no-op with group-reply, but makes sure list-reply has the
     * desired effect.  */
 
    if (!TAILQ_EMPTY(&env->mail_followup_to) &&
        !mutt_is_subscribed_list_recipient(false, env))
    {
      struct AddressList *al = NULL;
      if (!TAILQ_EMPTY(&env->reply_to))
        al = &env->reply_to;
      else if (!TAILQ_EMPTY(&env->from))
        al = &env->from;
 
      if (al)
      {
        struct Address *a = NULL;
        TAILQ_FOREACH_REVERSE(a, al, AddressList, entries)
        {
          mutt_addrlist_prepend(&env->mail_followup_to, mutt_addr_copy(a));
        }
      }
      else
      {
        mutt_addrlist_prepend(&env->mail_followup_to, mutt_default_from(sub));
      }
    }
 
    mutt_addrlist_dedupe(&env->mail_followup_to);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_send_list_subscribe()

bool mutt_send_list_subscribe	(	struct Mailbox *	m,
		struct Email *	e
	)

Send a mailing-list subscription email.

Parameters

m	Mailbox
e	Email carrying mailing-list subscription headers

Return values

true	Success
false	Failure

Definition at line 3007 of file send.c.

{
  if (!e || !e->env)
  {
    return false;
  }
 
  const char *mailto = e->env->list_subscribe;
  if (!mailto)
  {
    mutt_warning(_("No List-Subscribe header found"));
    return false;
  }
 
  struct EmailArray ea = ARRAY_HEAD_INITIALIZER;
  ARRAY_ADD(&ea, e);
  bool rc = send_simple_email(m, &ea, mailto, "Subscribe", "subscribe");
  ARRAY_FREE(&ea);
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_send_list_unsubscribe()

bool mutt_send_list_unsubscribe	(	struct Mailbox *	m,
		struct Email *	e
	)

Send a mailing-list unsubscription email.

Parameters

m	Mailbox
e	Email carrying mailing-list unsubscription headers

Return values

true	Success
false	Failure

Definition at line 3036 of file send.c.

{
  if (!e || !e->env)
  {
    return false;
  }
 
  const char *mailto = e->env->list_unsubscribe;
  if (!mailto)
  {
    mutt_warning(_("No List-Unsubscribe header found"));
    return false;
  }
 
  struct EmailArray ea = ARRAY_HEAD_INITIALIZER;
  ARRAY_ADD(&ea, e);
  bool rc = send_simple_email(m, &ea, mailto, "Unsubscribe", "unsubscribe");
  ARRAY_FREE(&ea);
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function: