send.c File Reference

Prepare and send an email. More...

#include "config.h"
#include <errno.h>
#include <limits.h>
#include <locale.h>
#include <regex.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <time.h>
#include <unistd.h>
#include "mutt/mutt.h"
#include "config/lib.h"
#include "email/lib.h"
#include "mutt.h"
#include "send.h"
#include "alias.h"
#include "compose.h"
#include "context.h"
#include "copy.h"
#include "curs_lib.h"
#include "edit.h"
#include "filter.h"
#include "globals.h"
#include "hdrline.h"
#include "hook.h"
#include "mailbox.h"
#include "mutt_attach.h"
#include "mutt_header.h"
#include "mutt_logging.h"
#include "mutt_parse.h"
#include "muttlib.h"
#include "ncrypt/ncrypt.h"
#include "options.h"
#include "pattern.h"
#include "protos.h"
#include "rfc3676.h"
#include "sendlib.h"
#include "smtp.h"
#include "sort.h"
#include "mx.h"
#include "nntp/nntp.h"
#include "notmuch/mutt_notmuch.h"
#include "imap/imap.h"

Include dependency graph for send.c:

Go to the source code of this file.

Functions
static void	append_signature (FILE *fp)
	Append a signature to an email. More...
static struct Address *	remove_user (struct Address *a, bool leave_only)
	Remove any address which matches the current user. More...
static struct Address *	find_mailing_lists (struct Address *t, struct Address *c)
	Search Address lists for mailing lists. More...
static int	edit_address (struct Address **a, const char *field)
	Edit an email address. More...
static int	edit_envelope (struct Envelope *en, SendFlags flags)
	Edit Envelope fields. More...
static char *	nntp_get_header (const char *s)
	Get the trimmed header. More...
static void	process_user_recips (struct Envelope *env)
	Process the user headers. More...
static void	process_user_header (struct Envelope *env)
	Process the user headers. More...
void	mutt_forward_intro (struct Mailbox *m, struct Email *e, FILE *fp)
	Add the "start of forwarded message" text. More...
void	mutt_forward_trailer (struct Mailbox *m, struct Email *e, FILE *fp)
	Add a "end of forwarded message" text. More...
static int	include_forward (struct Mailbox *m, struct Email *e, FILE *fp_out)
	Write out a forwarded message. More...
void	mutt_make_attribution (struct Mailbox *m, struct Email *e, FILE *fp_out)
	Add "on DATE, PERSON wrote" header. More...
void	mutt_make_post_indent (struct Mailbox *m, struct Email *e, FILE *fp_out)
	Add suffix to replied email text. More...
static int	include_reply (struct Mailbox *m, struct Email *e, FILE *fp_out)
	Generate the reply text for an email. More...
static int	default_to (struct Address **to, struct Envelope *env, SendFlags flags, int hmfupto)
	Generate default email addresses. More...
int	mutt_fetch_recips (struct Envelope *out, struct Envelope *in, SendFlags flags)
	Generate recpients for a reply email. More...
static void	add_references (struct ListHead *head, struct Envelope *env)
	Add the email's references to a list. More...
static void	add_message_id (struct ListHead *head, struct Envelope *env)
	Add the email's message ID to a list. More...
void	mutt_fix_reply_recipients (struct Envelope *env)
	Remove duplicate recipients. More...
void	mutt_make_forward_subject (struct Envelope *env, struct Mailbox *m, struct Email *cur)
	Create a subject for a forwarded email. More...
void	mutt_make_misc_reply_headers (struct Envelope *env, struct Envelope *curenv)
	Set subject for a reply. More...
void	mutt_add_to_reference_headers (struct Envelope *env, struct Envelope *curenv)
	Generate references for a reply email. More...
static void	make_reference_headers (struct EmailList *el, struct Envelope *env)
	Generate reference headers for an email. More...
static int	envelope_defaults (struct Envelope *env, struct Mailbox *m, struct EmailList *el, SendFlags flags)
	Fill in some defaults for a new email. More...
static int	generate_body (FILE *fp_tmp, struct Email *msg, SendFlags flags, struct Mailbox *m, struct EmailList *el)
	Create a new email body. More...
void	mutt_set_followup_to (struct Envelope *env)
	Set followup-to field. More...
static struct Address *	set_reverse_name (struct Envelope *env)
	Try to set the 'from' field from the recipients. More...
struct Address *	mutt_default_from (void)
	Get a default 'from' Address. More...
static int	send_message (struct Email *msg)
	Send an email. More...
void	mutt_encode_descriptions (struct Body *b, bool recurse)
	rfc2047 encode the content-descriptions More...
static void	decode_descriptions (struct Body *b)
	rfc2047 decode them in case of an error More...
static void	fix_end_of_file (const char *data)
	Ensure a file ends with a linefeed. More...
int	mutt_resend_message (FILE *fp, struct Context *ctx, struct Email *cur)
	Resend an email. More...
static bool	is_reply (struct Email *reply, struct Email *orig)
	Is one email a reply to another? More...
static bool	search_attach_keyword (char *filename)
	Search an email for 'attachment' keywords. More...
static int	save_fcc (struct Email *msg, char *fcc, size_t fcc_len, struct Body *clear_content, char *pgpkeylist, SendFlags flags, char **finalpath)
	Save an Email to a 'sent mail' folder. More...
static int	postpone_message (struct Email *msg, struct Email *cur, char *fcc, SendFlags flags)
	Save an Email for another day. More...
int	ci_send_message (SendFlags flags, struct Email *msg, const char *tempfile, struct Context *ctx, struct EmailList *el)
	Send an email. More...

Variables
unsigned char	C_AbortNoattach
	Config: Abort sending the email if attachments are missing. More...
struct Regex *	C_AbortNoattachRegex
	Config: Regex to match text indicating attachments are expected. More...
unsigned char	C_AbortNosubject
	Config: Abort creating the email if subject is missing. More...
unsigned char	C_AbortUnmodified
	Config: Abort the sending if the message hasn't been edited. More...
bool	C_AskFollowUp
	Config: (nntp) Ask the user for follow-up groups before editing. More...
bool	C_AskXCommentTo
	Config: (nntp) Ask the user for the 'X-Comment-To' field before editing. More...
char *	C_ContentType
	Config: Default "Content-Type" for newly composed messages. More...
bool	C_CryptAutoencrypt
	Config: Automatically PGP encrypt all outgoing mail. More...
bool	C_CryptAutopgp
	Config: Allow automatic PGP functions. More...
bool	C_CryptAutosign
	Config: Automatically PGP sign all outgoing mail. More...
bool	C_CryptAutosmime
	Config: Allow automatic SMIME functions. More...
bool	C_CryptReplyencrypt
	Config: Encrypt replies to encrypted messages. More...
bool	C_CryptReplysign
	Config: Sign replies to signed messages. More...
bool	C_CryptReplysignencrypted
	Config: Sign replies to encrypted messages. More...
char *	C_EmptySubject
	Config: Subject to use when replying to an email with none. More...
bool	C_FastReply
	Config: Don't prompt for the recipients and subject when replying/forwarding. More...
unsigned char	C_FccAttach
	Config: Save send message with all their attachments. More...
bool	C_FccClear
	Config: Save sent messages unencrypted and unsigned. More...
bool	C_FollowupTo
	Config: Add the 'Mail-Followup-To' header is generated when sending mail. More...
char *	C_ForwardAttributionIntro
	Config: Prefix message for forwarded messages. More...
char *	C_ForwardAttributionTrailer
	Config: Suffix message for forwarded messages. More...
unsigned char	C_ForwardEdit
	Config: Automatically start the editor when forwarding a message. More...
char *	C_ForwardFormat
	Config: printf-like format string to control the subject when forwarding a message. More...
bool	C_ForwardReferences
	Config: Set the 'In-Reply-To' and 'References' headers when forwarding a message. More...
bool	C_Hdrs
	Config: Add custom headers to outgoing mail. More...
unsigned char	C_HonorFollowupTo
	Config: Honour the 'Mail-Followup-To' header when group replying. More...
bool	C_IgnoreListReplyTo
	Config: Ignore the 'Reply-To' header when using <reply> on a mailing list. More...
unsigned char	C_Include
	Config: Include a copy of the email that's being replied to. More...
bool	C_Metoo
	Config: Remove the user's address from the list of recipients. More...
bool	C_NmRecord
	Config: (notmuch) If the 'record' mailbox (sent mail) should be indexed. More...
bool	C_PgpReplyinline
	Config: Reply using old-style inline PGP messages (not recommended) More...
char *	C_PostIndentString
	Config: Suffix message to add after reply text. More...
bool	C_PostponeEncrypt
	Config: Self-encrypt postponed messages. More...
char *	C_PostponeEncryptAs
	Config: Fallback encryption key for postponed messages. More...
unsigned char	C_Recall
	Config: Recall postponed mesaages when asked to compose a message. More...
bool	C_ReplySelf
	Config: Really reply to yourself, when replying to your own email. More...
unsigned char	C_ReplyTo
	Config: Address to use as a 'Reply-To' header. More...
bool	C_ReplyWithXorig
	Config: Create 'From' header from 'X-Original-To' header. More...
bool	C_ReverseName
	Config: Set the 'From' from the address the email was sent to. More...
bool	C_ReverseRealname
	Config: Set the 'From' from the full 'To' address the email was sent to. More...
bool	C_SigDashes
	Config: Insert '– ' before the signature. More...
char *	C_Signature
	Config: File containing a signature to append to all mail. More...
bool	C_SigOnTop
	Config: Insert the signature before the quoted text. More...
bool	C_UseFrom
	Config: Set the 'From' header for outgoing mail. More...

Detailed Description

Prepare and send an email.

Authors

• Michael R. Elkins

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

Function Documentation

static void append_signature ( FILE *  fp )

static

Append a signature to an email.

Parameters

fp	File to write to

Definition at line 133 of file send.c.

{
  FILE *fp_tmp = NULL;
  pid_t pid;

  if (C_Signature && (fp_tmp = mutt_open_read(C_Signature, &pid)))
  {
    if (C_SigDashes)
      fputs("\n-- \n", fp);
    mutt_file_copy_stream(fp_tmp, fp);
    mutt_file_fclose(&fp_tmp);
    if (pid != -1)
      mutt_wait_filter(pid);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct Address* remove_user ( struct Address *  a, bool  leave_only  )

static

Remove any address which matches the current user.

Parameters

a	List of addresses
leave_only	If set, don't remove the user's address if it it the only one in the list

Return values

ptr	Head of the remaining Address List

Definition at line 156 of file send.c.

{
  struct Address *top = NULL, *last = NULL;

  while (a)
  {
    if (!mutt_addr_is_user(a))
    {
      if (top)
      {
        last->next = a;
        last = last->next;
      }
      else
      {
        last = a;
        top = a;
      }
      a = a->next;
      last->next = NULL;
    }
    else
    {
      struct Address *tmp = a;

      a = a->next;
      if (!leave_only || a || last)
      {
        tmp->next = NULL;
        mutt_addr_free(&tmp);
      }
      else
      {
        last = tmp;
        top = tmp;
      }
    }
  }
  return top;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct Address* find_mailing_lists ( struct Address *  t, struct Address *  c  )

static

Search Address lists for mailing lists.

Parameters

t	'To' Address list
c	'Cc' Address list

Return values

ptr	Newly allocated Address list of all mailing list matches

Definition at line 203 of file send.c.

{
  struct Address *top = NULL, *ptr = NULL;

  for (; t || c; t = c, c = NULL)
  {
    for (; t; t = t->next)
    {
      if (mutt_is_mail_list(t) && !t->group)
      {
        if (top)
        {
          ptr->next = mutt_addr_copy(t);
          ptr = ptr->next;
        }
        else
        {
          top = mutt_addr_copy(t);
          ptr = top;
        }
      }
    }
  }
  return top;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int edit_address ( struct Address **  a, const char *  field  )

static

Edit an email address.

Parameters

[out]	a	Address to edit
[in]	field	Prompt for user

Return values

0	Success
-1	Failure

Definition at line 236 of file send.c.

{
  char buf[8192];
  char *err = NULL;
  int idna_ok = 0;

  do
  {
    buf[0] = '\0';
    mutt_addrlist_to_local(*a);
    mutt_addr_write(buf, sizeof(buf), *a, false);
    if (mutt_get_field(field, buf, sizeof(buf), MUTT_ALIAS) != 0)
      return -1;
    mutt_addr_free(a);
    *a = mutt_expand_aliases(mutt_addr_parse_list2(NULL, buf));
    idna_ok = mutt_addrlist_to_intl(*a, &err);
    if (idna_ok != 0)
    {
      mutt_error(_("Bad IDN: '%s'"), err);
      FREE(&err);
    }
  } while (idna_ok != 0);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int edit_envelope ( struct Envelope *  en, SendFlags  flags  )

static

Edit Envelope fields.

Parameters

en	Envelope to edit
flags	Flags, see SendFlags

Return values

0	Success
-1	Failure

Definition at line 268 of file send.c.

{
  char buf[8192];

#ifdef USE_NNTP
  if (OptNewsSend)
  {
    if (en->newsgroups)
      mutt_str_strfcpy(buf, en->newsgroups, sizeof(buf));
    else
      buf[0] = '\0';
    if (mutt_get_field("Newsgroups: ", buf, sizeof(buf), 0) != 0)
      return -1;
    FREE(&en->newsgroups);
    en->newsgroups = mutt_str_strdup(buf);

    if (en->followup_to)
      mutt_str_strfcpy(buf, en->followup_to, sizeof(buf));
    else
      buf[0] = '\0';
    if (C_AskFollowUp && (mutt_get_field("Followup-To: ", buf, sizeof(buf), 0) != 0))
    {
      return -1;
    }
    FREE(&en->followup_to);
    en->followup_to = mutt_str_strdup(buf);

    if (en->x_comment_to)
      mutt_str_strfcpy(buf, en->x_comment_to, sizeof(buf));
    else
      buf[0] = '\0';
    if (C_XCommentTo && C_AskXCommentTo &&
        (mutt_get_field("X-Comment-To: ", buf, sizeof(buf), 0) != 0))
    {
      return -1;
    }
    FREE(&en->x_comment_to);
    en->x_comment_to = mutt_str_strdup(buf);
  }
  else
#endif
  {
    if ((edit_address(&en->to, _("To: ")) == -1) || !en->to)
      return -1;
    if (C_Askcc && (edit_address(&en->cc, _("Cc: ")) == -1))
      return -1;
    if (C_Askbcc && (edit_address(&en->bcc, _("Bcc: ")) == -1))
      return -1;
    if (C_ReplyWithXorig && (flags & (SEND_REPLY | SEND_LIST_REPLY | SEND_GROUP_REPLY)) &&
        (edit_address(&en->from, "From: ") == -1))
    {
      return -1;
    }
  }

  if (en->subject)
  {
    if (C_FastReply)
      return 0;
    else
      mutt_str_strfcpy(buf, en->subject, sizeof(buf));
  }
  else
  {
    const char *p = NULL;

    buf[0] = '\0';
    struct ListNode *uh = NULL;
    STAILQ_FOREACH(uh, &UserHeader, entries)
    {
      size_t plen = mutt_str_startswith(uh->data, "subject:", CASE_IGNORE);
      if (plen)
      {
        p = mutt_str_skip_email_wsp(uh->data + plen);
        mutt_str_strfcpy(buf, p, sizeof(buf));
      }
    }
  }

  if ((mutt_get_field(_("Subject: "), buf, sizeof(buf), 0) != 0) ||
      (!buf[0] &&
       (query_quadoption(C_AbortNosubject, _("No subject, abort?")) != MUTT_NO)))
  {
    mutt_message(_("No subject, aborting"));
    return -1;
  }
  mutt_str_replace(&en->subject, buf);

  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static char* nntp_get_header ( const char *  s )

static

Get the trimmed header.

Parameters

s	Header line with leading whitespace

Return values

ptr	Copy of string

Note

The caller should free the returned string.

Definition at line 367 of file send.c.

{
  SKIPWS(s);
  return mutt_str_strdup(s);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void process_user_recips ( struct Envelope *  env )

static

Process the user headers.

Parameters

env	Envelope to populate

Definition at line 378 of file send.c.

{
  struct ListNode *uh = NULL;
  STAILQ_FOREACH(uh, &UserHeader, entries)
  {
    size_t plen;
    if ((plen = mutt_str_startswith(uh->data, "to:", CASE_IGNORE)))
      env->to = mutt_addr_parse_list(env->to, uh->data + plen);
    else if ((plen = mutt_str_startswith(uh->data, "cc:", CASE_IGNORE)))
      env->cc = mutt_addr_parse_list(env->cc, uh->data + plen);
    else if ((plen = mutt_str_startswith(uh->data, "bcc:", CASE_IGNORE)))
      env->bcc = mutt_addr_parse_list(env->bcc, uh->data + plen);
#ifdef USE_NNTP
    else if ((plen = mutt_str_startswith(uh->data, "newsgroups:", CASE_IGNORE)))
      env->newsgroups = nntp_get_header(uh->data + plen);
    else if ((plen = mutt_str_startswith(uh->data, "followup-to:", CASE_IGNORE)))
      env->followup_to = nntp_get_header(uh->data + plen);
    else if ((plen = mutt_str_startswith(uh->data, "x-comment-to:", CASE_IGNORE)))
      env->x_comment_to = nntp_get_header(uh->data + plen);
#endif
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void process_user_header ( struct Envelope *  env )

static

Process the user headers.

Parameters

env	Envelope to populate

Definition at line 405 of file send.c.

{
  struct ListNode *uh = NULL;
  STAILQ_FOREACH(uh, &UserHeader, entries)
  {
    size_t plen;
    if ((plen = mutt_str_startswith(uh->data, "from:", CASE_IGNORE)))
    {
      /* User has specified a default From: address.  Remove default address */
      mutt_addr_free(&env->from);
      env->from = mutt_addr_parse_list(env->from, uh->data + plen);
    }
    else if ((plen = mutt_str_startswith(uh->data, "reply-to:", CASE_IGNORE)))
    {
      mutt_addr_free(&env->reply_to);
      env->reply_to = mutt_addr_parse_list(env->reply_to, uh->data + plen);
    }
    else if ((plen = mutt_str_startswith(uh->data, "message-id:", CASE_IGNORE)))
    {
      char *tmp = mutt_extract_message_id(uh->data + plen, NULL);
      if (mutt_addr_valid_msgid(tmp))
      {
        FREE(&env->message_id);
        env->message_id = tmp;
      }
      else
        FREE(&tmp);
    }
    else if (!mutt_str_startswith(uh->data, "to:", CASE_IGNORE) &&
             !mutt_str_startswith(uh->data, "cc:", CASE_IGNORE) &&
             !mutt_str_startswith(uh->data, "bcc:", CASE_IGNORE) &&
#ifdef USE_NNTP
             !mutt_str_startswith(uh->data, "newsgroups:", CASE_IGNORE) &&
             !mutt_str_startswith(uh->data, "followup-to:", CASE_IGNORE) &&
             !mutt_str_startswith(uh->data, "x-comment-to:", CASE_IGNORE) &&
#endif
             !mutt_str_startswith(uh->data, "supersedes:", CASE_IGNORE) &&
             !mutt_str_startswith(uh->data, "subject:", CASE_IGNORE) &&
             !mutt_str_startswith(uh->data, "return-path:", CASE_IGNORE))
    {
      mutt_list_insert_tail(&env->userhdrs, mutt_str_strdup(uh->data));
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void mutt_forward_intro	(	struct Mailbox *	m,
		struct Email *	e,
		FILE *	fp
	)

Add the "start of forwarded message" text.

Parameters

m	Mailbox
e	Email
fp	File to write to

Definition at line 456 of file send.c.

{
  if (!C_ForwardAttributionIntro || !fp)
    return;

  char buf[1024];
  setlocale(LC_TIME, NONULL(C_AttributionLocale));
  mutt_make_string(buf, sizeof(buf), C_ForwardAttributionIntro, NULL, m, e);
  setlocale(LC_TIME, "");
  fputs(buf, fp);
  fputs("\n\n", fp);
}

Here is the caller graph for this function:

void mutt_forward_trailer	(	struct Mailbox *	m,
		struct Email *	e,
		FILE *	fp
	)

Add a "end of forwarded message" text.

Parameters

m	Mailbox
e	Email
fp	File to write to

Definition at line 475 of file send.c.

{
  if (!C_ForwardAttributionTrailer || !fp)
    return;

  char buf[1024];
  setlocale(LC_TIME, NONULL(C_AttributionLocale));
  mutt_make_string(buf, sizeof(buf), C_ForwardAttributionTrailer, NULL, m, e);
  setlocale(LC_TIME, "");
  fputc('\n', fp);
  fputs(buf, fp);
  fputc('\n', fp);
}

Here is the caller graph for this function:

static int include_forward ( struct Mailbox *  m, struct Email *  e, FILE *  fp_out  )

static

Write out a forwarded message.

Parameters

m	Mailbox
e	Email
fp_out	File to write to

Return values

0	Success
-1	Failure

Definition at line 497 of file send.c.

{
  CopyHeaderFlags chflags = CH_DECODE;
  CopyMessageFlags cmflags = MUTT_CM_NO_FLAGS;

  mutt_parse_mime_message(m, e);
  mutt_message_hook(m, e, MUTT_MESSAGE_HOOK);

  if ((WithCrypto != 0) && (e->security & SEC_ENCRYPT) && C_ForwardDecode)
  {
    /* make sure we have the user's passphrase before proceeding... */
    if (!crypt_valid_passphrase(e->security))
      return -1;
  }

  mutt_forward_intro(m, e, fp_out);

  if (C_ForwardDecode)
  {
    cmflags |= MUTT_CM_DECODE | MUTT_CM_CHARCONV;
    if (C_Weed)
    {
      chflags |= CH_WEED | CH_REORDER;
      cmflags |= MUTT_CM_WEED;
    }
  }
  if (C_ForwardQuote)
    cmflags |= MUTT_CM_PREFIX;

  /* wrapping headers for forwarding is considered a display
   * rather than send action */
  chflags |= CH_DISPLAY;

  mutt_copy_message_ctx(fp_out, m, e, cmflags, chflags);
  mutt_forward_trailer(m, e, fp_out);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void mutt_make_attribution	(	struct Mailbox *	m,
		struct Email *	e,
		FILE *	fp_out
	)

Add "on DATE, PERSON wrote" header.

Parameters

m	Mailbox
e	Email
fp_out	File to write to

Definition at line 541 of file send.c.

{
  if (!C_Attribution || !fp_out)
    return;

  char buf[1024];
  setlocale(LC_TIME, NONULL(C_AttributionLocale));
  mutt_make_string(buf, sizeof(buf), C_Attribution, NULL, m, e);
  setlocale(LC_TIME, "");
  fputs(buf, fp_out);
  fputc('\n', fp_out);
}

Here is the caller graph for this function:

void mutt_make_post_indent	(	struct Mailbox *	m,
		struct Email *	e,
		FILE *	fp_out
	)

Add suffix to replied email text.

Parameters

m	Mailbox
e	Email
fp_out	File to write to

Definition at line 560 of file send.c.

{
  if (!C_PostIndentString || !fp_out)
    return;

  char buf[256];
  mutt_make_string(buf, sizeof(buf), C_PostIndentString, NULL, m, e);
  fputs(buf, fp_out);
  fputc('\n', fp_out);
}

Here is the caller graph for this function:

static int include_reply ( struct Mailbox *  m, struct Email *  e, FILE *  fp_out  )

static

Generate the reply text for an email.

Parameters

m	Mailbox
e	Email
fp_out	File to write to

Return values

0	Success
-1	Failure

Definition at line 579 of file send.c.

{
  CopyMessageFlags cmflags =
      MUTT_CM_PREFIX | MUTT_CM_DECODE | MUTT_CM_CHARCONV | MUTT_CM_REPLYING;
  CopyHeaderFlags chflags = CH_DECODE;

  if ((WithCrypto != 0) && (e->security & SEC_ENCRYPT))
  {
    /* make sure we have the user's passphrase before proceeding... */
    if (!crypt_valid_passphrase(e->security))
      return -1;
  }

  mutt_parse_mime_message(m, e);
  mutt_message_hook(m, e, MUTT_MESSAGE_HOOK);

  mutt_make_attribution(m, e, fp_out);

  if (!C_Header)
    cmflags |= MUTT_CM_NOHEADER;
  if (C_Weed)
  {
    chflags |= CH_WEED | CH_REORDER;
    cmflags |= MUTT_CM_WEED;
  }

  mutt_copy_message_ctx(fp_out, m, e, cmflags, chflags);

  mutt_make_post_indent(m, e, fp_out);

  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int default_to ( struct Address **  to, struct Envelope *  env, SendFlags  flags, int  hmfupto  )

static

Generate default email addresses.

Parameters

[out]	to	'To' address
[in]	env	Envelope to populate
[in]	flags	Flags, see SendFlags
[in]	hmfupto	If true, add 'followup-to' address to 'to' address

Return values

0	Success
-1	Aborted

Definition at line 621 of file send.c.

{
  char prompt[256];

  if (flags && env->mail_followup_to && (hmfupto == MUTT_YES))
  {
    mutt_addr_append(to, env->mail_followup_to, true);
    return 0;
  }

  /* Exit now if we're setting up the default Cc list for list-reply
   * (only set if Mail-Followup-To is present and honoured).  */
  if (flags & SEND_LIST_REPLY)
    return 0;

  if (!C_ReplySelf && mutt_addr_is_user(env->from))
  {
    /* mail is from the user, assume replying to recipients */
    mutt_addr_append(to, env->to, true);
  }
  else if (env->reply_to)
  {
    if ((mutt_addr_cmp(env->from, env->reply_to) && !env->reply_to->next &&
         !env->reply_to->personal) ||
        (C_IgnoreListReplyTo && mutt_is_mail_list(env->reply_to) &&
         (mutt_addr_search(env->reply_to, env->to) ||
          mutt_addr_search(env->reply_to, env->cc))))
    {
      /* If the Reply-To: address is a mailing list, assume that it was
       * put there by the mailing list, and use the From: address
       *
       * We also take the from header if our correspondent has a reply-to
       * header which is identical to the electronic mail address given
       * in his From header, and the reply-to has no display-name.  */
      mutt_addr_append(to, env->from, false);
    }
    else if (!(mutt_addr_cmp(env->from, env->reply_to) && !env->reply_to->next) &&
             (C_ReplyTo != MUTT_YES))
    {
      /* There are quite a few mailing lists which set the Reply-To:
       * header field to the list address, which makes it quite impossible
       * to send a message to only the sender of the message.  This
       * provides a way to do that.  */
      /* L10N: Asks whether the user respects the reply-to header.
         If she says no, neomutt will reply to the from header's address instead. */
      snprintf(prompt, sizeof(prompt), _("Reply to %s%s?"),
               env->reply_to->mailbox, env->reply_to->next ? ",..." : "");
      switch (query_quadoption(C_ReplyTo, prompt))
      {
        case MUTT_YES:
          mutt_addr_append(to, env->reply_to, false);
          break;

        case MUTT_NO:
          mutt_addr_append(to, env->from, false);
          break;

        default:
          return -1; /* abort */
      }
    }
    else
      mutt_addr_append(to, env->reply_to, false);
  }
  else
    mutt_addr_append(to, env->from, false);

  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Generate recpients for a reply email.

Parameters

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

Return values

0	Success
-1	Failure

Definition at line 699 of file send.c.

{
  struct Address *tmp = NULL;
  enum QuadOption hmfupto = MUTT_ABORT;

  if ((flags & (SEND_LIST_REPLY | SEND_GROUP_REPLY | SEND_GROUP_CHAT_REPLY)) && in->mail_followup_to)
  {
    char prompt[256];
    snprintf(prompt, sizeof(prompt), _("Follow-up to %s%s?"),
             in->mail_followup_to->mailbox, in->mail_followup_to->next ? ",..." : "");

    hmfupto = query_quadoption(C_HonorFollowupTo, prompt);
    if (hmfupto == MUTT_ABORT)
      return -1;
  }

  if (flags & SEND_LIST_REPLY)
  {
    tmp = find_mailing_lists(in->to, in->cc);
    mutt_addr_append(&out->to, tmp, false);
    mutt_addr_free(&tmp);

    if (in->mail_followup_to && (hmfupto == MUTT_YES) &&
        (default_to(&out->cc, in, flags & SEND_LIST_REPLY, (hmfupto == MUTT_YES)) == MUTT_ABORT))
    {
      return -1; /* abort */
    }
  }
  else if (flags & SEND_TO_SENDER)
  {
    mutt_addr_append(&out->to, in->from, false);
  }
  else
  {
    if (default_to(&out->to, in, flags & (SEND_GROUP_REPLY | SEND_GROUP_CHAT_REPLY),
                   (hmfupto == MUTT_YES)) == -1)
      return -1; /* abort */

    if ((flags & (SEND_GROUP_REPLY | SEND_GROUP_CHAT_REPLY)) &&
        (!in->mail_followup_to || (hmfupto != MUTT_YES)))
    {
      /* if(!mutt_addr_is_user(in->to)) */
      if (flags & SEND_GROUP_REPLY)
        mutt_addr_append(&out->cc, in->to, true);
      else
        mutt_addr_append(&out->to, in->to, true);
      mutt_addr_append(&out->cc, in->cc, true);
    }
  }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void add_references ( struct ListHead *  head, struct Envelope *  env  )

static

Add the email's references to a list.

Parameters

head	List of references
env	Envelope of message

Definition at line 756 of file send.c.

{
  struct ListNode *np = NULL;

  struct ListHead *src = !STAILQ_EMPTY(&env->references) ? &env->references : &env->in_reply_to;
  STAILQ_FOREACH(np, src, entries)
  {
    mutt_list_insert_tail(head, mutt_str_strdup(np->data));
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void add_message_id ( struct ListHead *  head, struct Envelope *  env  )

static

Add the email's message ID to a list.

Parameters

head	List of message IDs
env	Envelope of message

Definition at line 772 of file send.c.

{
  if (env->message_id)
  {
    mutt_list_insert_head(head, mutt_str_strdup(env->message_id));
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void mutt_fix_reply_recipients

(

struct Envelope *

env

)

Remove duplicate recipients.

Parameters

env	Envelope to fix

Definition at line 784 of file send.c.

{
  if (!C_Metoo)
  {
    /* 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 */
    env->cc = remove_user(env->cc, (env->to == NULL));
    env->to = remove_user(env->to, (env->cc == NULL) || C_ReplySelf);
  }

  /* the CC field can get cluttered, especially with lists */
  env->to = mutt_addrlist_dedupe(env->to);
  env->cc = mutt_addrlist_dedupe(env->cc);
  env->cc = mutt_addr_remove_xrefs(env->to, env->cc);

  if (env->cc && !env->to)
  {
    env->to = env->cc;
    env->cc = NULL;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void mutt_make_forward_subject	(	struct Envelope *	env,
		struct Mailbox *	m,
		struct Email *	cur
	)

Create a subject for a forwarded email.

Parameters

env	Envelope for result
m	Mailbox
cur	Email

Definition at line 812 of file send.c.

{
  if (!env)
    return;

  char buf[256];

  /* set the default subject for the message. */
  mutt_make_string(buf, sizeof(buf), NONULL(C_ForwardFormat), NULL, m, cur);
  mutt_str_replace(&env->subject, buf);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void mutt_make_misc_reply_headers	(	struct Envelope *	env,
		struct Envelope *	curenv
	)

Set subject for a reply.

Parameters

env	Envelope for result
curenv	Envelope of source email

Definition at line 829 of file send.c.

{
  if (!env || !curenv)
    return;

  /* This takes precedence over a subject that might have
   * been taken from a List-Post header.  Is that correct?  */
  if (curenv->real_subj)
  {
    FREE(&env->subject);
    env->subject = mutt_mem_malloc(mutt_str_strlen(curenv->real_subj) + 5);
    sprintf(env->subject, "Re: %s", curenv->real_subj);
  }
  else if (!env->subject)
    env->subject = mutt_str_strdup(C_EmptySubject);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void mutt_add_to_reference_headers	(	struct Envelope *	env,
		struct Envelope *	curenv
	)

Generate references for a reply email.

Parameters

env	Envelope for result
curenv	Envelope of source email

Definition at line 851 of file send.c.

{
  add_references(&env->references, curenv);
  add_message_id(&env->references, curenv);
  add_message_id(&env->in_reply_to, curenv);

#ifdef USE_NNTP
  if (OptNewsSend && C_XCommentTo && curenv->from)
    env->x_comment_to = mutt_str_strdup(mutt_get_name(curenv->from));
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void make_reference_headers ( struct EmailList *  el, struct Envelope *  env  )

static

Generate reference headers for an email.

Parameters

el	List of source Emails
env	Envelope for result

Definition at line 868 of file send.c.

{
  if (!el || !env || STAILQ_EMPTY(el))
    return;

  struct EmailNode *en = STAILQ_FIRST(el);
  bool single = !STAILQ_NEXT(en, entries);

  if (!single)
  {
    STAILQ_FOREACH(en, el, entries)
    {
      mutt_add_to_reference_headers(env, en->email->env);
    }
  }
  else
    mutt_add_to_reference_headers(env, en->email->env);

  /* if there's more than entry in In-Reply-To (i.e. message has multiple
   * parents), don't generate a References: header as it's discouraged by
   * RFC2822, sect. 3.6.4 */
  if (!single && !STAILQ_EMPTY(&env->in_reply_to) &&
      STAILQ_NEXT(STAILQ_FIRST(&env->in_reply_to), entries))
  {
    mutt_list_free(&env->references);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int envelope_defaults ( struct Envelope *  env, struct Mailbox *  m, struct EmailList *  el, SendFlags  flags  )

static

Fill in some defaults for a new email.

Parameters

env	Envelope for result
m	Mailbox
el	List of Emails to use
flags	Flags, see SendFlags

Return values

0	Success
-1	Failure

Definition at line 905 of file send.c.

{
  if (!el || STAILQ_EMPTY(el))
    return -1;

  struct EmailNode *en = STAILQ_FIRST(el);
  bool single = !STAILQ_NEXT(en, entries);

  struct Envelope *curenv = en->email->env;
  if (!curenv)
    return -1;

  if (flags & (SEND_REPLY | SEND_TO_SENDER))
  {
#ifdef USE_NNTP
    if ((flags & SEND_NEWS))
    {
      /* in case followup set Newsgroups: with Followup-To: if it present */
      if (!env->newsgroups &&
          (mutt_str_strcasecmp(curenv->followup_to, "poster") != 0))
      {
        env->newsgroups = mutt_str_strdup(curenv->followup_to);
      }
    }
    else
#endif
        if (!single)
    {
      STAILQ_FOREACH(en, el, entries)
      {
        if (mutt_fetch_recips(env, en->email->env, flags) == -1)
          return -1;
      }
    }
    else if (mutt_fetch_recips(env, curenv, flags) == -1)
      return -1;

    if ((flags & SEND_LIST_REPLY) && !env->to)
    {
      mutt_error(_("No mailing lists found"));
      return -1;
    }

    if (flags & SEND_REPLY)
    {
      mutt_make_misc_reply_headers(env, curenv);
      make_reference_headers(el, env);
    }
  }
  else if (flags & SEND_FORWARD)
  {
    mutt_make_forward_subject(env, m, en->email);
    if (C_ForwardReferences)
      make_reference_headers(el, env);
  }

  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int generate_body ( FILE *  fp_tmp, struct Email *  msg, SendFlags  flags, struct Mailbox *  m, struct EmailList *  el  )

static

Create a new email body.

Parameters

fp_tmp	Stream for outgoing message
msg	Header for outgoing message
flags	Compose mode, see SendFlags
m	Mailbox
el	List of Emails to use

Return values

0	Success
-1	Error

Definition at line 975 of file send.c.

{
  struct Body *tmp = NULL;
  struct EmailNode *en = NULL;
  bool single = true;

  if (el)
    en = STAILQ_FIRST(el);
  if (en)
    single = !STAILQ_NEXT(en, entries);

  /* An EmailList is required for replying and forwarding */
  if (!el && (flags & (SEND_REPLY | SEND_FORWARD)))
    return -1;

  if (flags & SEND_REPLY)
  {
    enum QuadOption ans =
        query_quadoption(C_Include, _("Include message in reply?"));
    if (ans == MUTT_ABORT)
      return -1;

    if (ans == MUTT_YES)
    {
      mutt_message(_("Including quoted message..."));
      if (!single)
      {
        STAILQ_FOREACH(en, el, entries)
        {
          if (include_reply(m, en->email, fp_tmp) == -1)
          {
            mutt_error(_("Could not include all requested messages"));
            return -1;
          }
          fputc('\n', fp_tmp);
        }
      }
      else
        include_reply(m, en->email, fp_tmp);
    }
  }
  else if (flags & SEND_FORWARD)
  {
    enum QuadOption ans =
        query_quadoption(C_MimeForward, _("Forward as attachment?"));
    if (ans == MUTT_YES)
    {
      struct Body *last = msg->content;

      mutt_message(_("Preparing forwarded message..."));

      while (last && last->next)
        last = last->next;

      if (single)
      {
        tmp = mutt_make_message_attach(m, en->email, false);
        if (last)
          last->next = tmp;
        else
          msg->content = tmp;
      }
      else
      {
        STAILQ_FOREACH(en, el, entries)
        {
          tmp = mutt_make_message_attach(m, en->email, false);
          if (last)
          {
            last->next = tmp;
            last = tmp;
          }
          else
          {
            last = tmp;
            msg->content = tmp;
          }
        }
      }
    }
    else if (ans != MUTT_ABORT)
    {
      if (single)
        include_forward(m, en->email, fp_tmp);
      else
      {
        STAILQ_FOREACH(en, el, entries)
        {
          include_forward(m, en->email, fp_tmp);
        }
      }
    }
    else
      return -1;
  }
  /* if (WithCrypto && (flags & SEND_KEY)) */
  else if (((WithCrypto & APPLICATION_PGP) != 0) && (flags & SEND_KEY))
  {
    struct Body *b = NULL;

    if (((WithCrypto & APPLICATION_PGP) != 0) && !(b = crypt_pgp_make_key_attachment()))
    {
      return -1;
    }

    b->next = msg->content;
    msg->content = b;
  }

  mutt_clear_error();

  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void mutt_set_followup_to

(

struct Envelope *

env

)

Set followup-to field.

Parameters

env	Envelope to modify

Definition at line 1094 of file send.c.

{
  struct Address *t = NULL;
  struct Address *from = NULL;

  /* Only generate the Mail-Followup-To if the user has requested it, and
   * it hasn't already been set */

  if (!C_FollowupTo)
    return;
#ifdef USE_NNTP
  if (OptNewsSend)
  {
    if (!env->followup_to && env->newsgroups && (strrchr(env->newsgroups, ',')))
      env->followup_to = mutt_str_strdup(env->newsgroups);
    return;
  }
#endif

  if (!env->mail_followup_to)
  {
    if (mutt_is_list_cc(0, env->to, env->cc))
    {
      /* this message goes to known mailing lists, so create a proper
       * mail-followup-to header */

      t = mutt_addr_append(&env->mail_followup_to, env->to, false);
      mutt_addr_append(&t, env->cc, true);
    }

    /* remove ourselves from the mail-followup-to header */
    env->mail_followup_to = 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 (env->mail_followup_to && !mutt_is_list_recipient(false, env->to, env->cc))
    {
      if (env->reply_to)
        from = mutt_addr_copy_list(env->reply_to, false);
      else if (env->from)
        from = mutt_addr_copy_list(env->from, false);
      else
        from = mutt_default_from();

      if (from)
      {
        /* Normally, this loop will not even be entered. */
        for (t = from; t && t->next; t = t->next)
          ;

        t->next = env->mail_followup_to; /* t cannot be NULL at this point. */
        env->mail_followup_to = from;
      }
    }

    env->mail_followup_to = mutt_addrlist_dedupe(env->mail_followup_to);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct Address* set_reverse_name ( struct Envelope *  env )

static

Try to set the 'from' field from the recipients.

Parameters

env	Envelope to use

Return values

ptr	Newly allocated Address
NULL	A suitable Address wasn't found

Look through the recipients of the message we are replying to, and if we find an address that matches $alternates, we use that as the default from field

Definition at line 1166 of file send.c.

{
  struct Address *tmp = NULL;

  for (tmp = env->to; tmp; tmp = tmp->next)
  {
    if (mutt_addr_is_user(tmp))
      break;
  }
  if (!tmp)
  {
    for (tmp = env->cc; tmp; tmp = tmp->next)
    {
      if (mutt_addr_is_user(tmp))
        break;
    }
  }
  if (!tmp && mutt_addr_is_user(env->from))
    tmp = env->from;
  if (tmp)
  {
    tmp = mutt_addr_copy(tmp);
    /* when $reverse_realname is not set, clear the personal name so that it
     * may be set via a reply- or send-hook.  */
    if (!C_ReverseRealname)
      FREE(&tmp->personal);
  }
  return tmp;
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct Address* mutt_default_from

(

void

)

Get a default 'from' Address.

Return values

ptr	Newly allocated Address

Definition at line 1200 of file send.c.

{
  struct Address *addr = NULL;

  /* Note: We let $from override $realname here.
   *       Is this the right thing to do?
   */

  if (C_From)
    addr = mutt_addr_copy(C_From);
  else
  {
    addr = mutt_addr_new();
    if (C_UseDomain)
    {
      const char *fqdn = mutt_fqdn(true);
      addr->mailbox =
          mutt_mem_malloc(mutt_str_strlen(Username) + mutt_str_strlen(fqdn) + 2);
      sprintf(addr->mailbox, "%s@%s", NONULL(Username), NONULL(fqdn));
    }
    else
    {
      addr->mailbox = mutt_str_strdup(Username);
    }
  }

  return addr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int send_message ( struct Email *  msg )

static

Send an email.

Parameters

msg

Email

Return values

0	Success
-1	Failure

Definition at line 1235 of file send.c.

{
  char tempfile[PATH_MAX];
  int i;
#ifdef USE_SMTP
  short old_write_bcc;
#endif

  /* Write out the message in MIME form. */
  mutt_mktemp(tempfile, sizeof(tempfile));
  FILE *fp_tmp = mutt_file_fopen(tempfile, "w");
  if (!fp_tmp)
    return -1;

#ifdef USE_SMTP
  old_write_bcc = C_WriteBcc;
  if (C_SmtpUrl)
    C_WriteBcc = false;
#endif
#ifdef MIXMASTER
  mutt_rfc822_write_header(fp_tmp, msg->env, msg->content,
                           MUTT_WRITE_HEADER_NORMAL, !STAILQ_EMPTY(&msg->chain),
                           mutt_should_hide_protected_subject(msg));
#endif
#ifndef MIXMASTER
  mutt_rfc822_write_header(fp_tmp, msg->env, msg->content, MUTT_WRITE_HEADER_NORMAL,
                           false, mutt_should_hide_protected_subject(msg));
#endif
#ifdef USE_SMTP
  if (old_write_bcc)
    C_WriteBcc = true;
#endif

  fputc('\n', fp_tmp); /* tie off the header. */

  if ((mutt_write_mime_body(msg->content, fp_tmp) == -1))
  {
    mutt_file_fclose(&fp_tmp);
    unlink(tempfile);
    return -1;
  }

  if (fclose(fp_tmp) != 0)
  {
    mutt_perror(tempfile);
    unlink(tempfile);
    return -1;
  }

#ifdef MIXMASTER
  if (!STAILQ_EMPTY(&msg->chain))
    return mix_send_message(&msg->chain, tempfile);
#endif

#ifdef USE_SMTP
#ifdef USE_NNTP
  if (!OptNewsSend)
#endif
    if (C_SmtpUrl)
    {
      return mutt_smtp_send(msg->env->from, msg->env->to, msg->env->cc, msg->env->bcc,
                            tempfile, (msg->content->encoding == ENC_8BIT));
    }
#endif /* USE_SMTP */

  i = mutt_invoke_sendmail(msg->env->from, msg->env->to, msg->env->cc, msg->env->bcc,
                           tempfile, (msg->content->encoding == ENC_8BIT));
  return i;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void mutt_encode_descriptions	(	struct Body *	b,
		bool	recurse
	)

rfc2047 encode the content-descriptions

Parameters

b	Body of email
recurse	If true, encode children parts

Definition at line 1310 of file send.c.

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

Here is the call graph for this function:

Here is the caller graph for this function:

static void decode_descriptions ( struct Body *  b )

static

rfc2047 decode them in case of an error

Parameters

b	MIME parts to decode

Definition at line 1327 of file send.c.

{
  for (struct Body *t = b; t; t = t->next)
  {
    if (t->description)
    {
      rfc2047_decode(&t->description);
    }
    if (t->parts)
      decode_descriptions(t->parts);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void fix_end_of_file ( const char *  data )

static

Ensure a file ends with a linefeed.

Parameters

data	Name of file to fix

Definition at line 1344 of file send.c.

{
  FILE *fp = mutt_file_fopen(data, "a+");
  if (!fp)
    return;
  if (fseek(fp, -1, SEEK_END) >= 0)
  {
    int c = fgetc(fp);
    if (c != '\n')
      fputc('\n', fp);
  }
  mutt_file_fclose(&fp);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int mutt_resend_message	(	FILE *	fp,
		struct Context *	ctx,
		struct Email *	cur
	)

Resend an email.

Parameters

fp	File containing email
ctx	Mailbox
cur	Email to resend

Return values

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

Definition at line 1367 of file send.c.

{
  struct Email *msg = mutt_email_new();

  if (mutt_prepare_template(fp, ctx->mailbox, msg, cur, true) < 0)
  {
    mutt_email_free(&msg);
    return -1;
  }

  if (WithCrypto)
  {
    /* mutt_prepare_template doesn't always flip on an application bit.
     * so fix that here */
    if (!(msg->security & (APPLICATION_SMIME | APPLICATION_PGP)))
    {
      if (((WithCrypto & APPLICATION_SMIME) != 0) && C_SmimeIsDefault)
        msg->security |= APPLICATION_SMIME;
      else if (WithCrypto & APPLICATION_PGP)
        msg->security |= APPLICATION_PGP;
      else
        msg->security |= APPLICATION_SMIME;
    }

    if (C_CryptOpportunisticEncrypt)
    {
      msg->security |= SEC_OPPENCRYPT;
      crypt_opportunistic_encrypt(msg);
    }
  }

  struct EmailList el = STAILQ_HEAD_INITIALIZER(el);
  el_add_email(&el, cur);
  int rc = ci_send_message(SEND_RESEND, msg, NULL, ctx, &el);
  el_free(&el);

  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bool is_reply ( struct Email *  reply, struct Email *  orig  )

static

Is one email a reply to another?

Parameters

reply	Email to test
orig	Original email

Return values

true	It is a reply
false	It is not a reply

Definition at line 1413 of file send.c.

{
  if (!reply || !reply->env || !orig || !orig->env)
    return false;
  return mutt_list_find(&orig->env->references, reply->env->message_id) ||
         mutt_list_find(&orig->env->in_reply_to, reply->env->message_id);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bool search_attach_keyword ( char *  filename )

static

Search an email for 'attachment' keywords.

Parameters

filename

Filename

Return values

true	If the regex matches in the email

Search an email for the regex in $abort_noattach_regex. A match might indicate that the user should have attached something.

Note

Quoted lines (as defined by $quote_regex) are ignored

Definition at line 1431 of file send.c.

{
  /* Search for the regex in C_AbortNoattachRegex within a file */
  if (!C_AbortNoattachRegex || !C_AbortNoattachRegex->regex || !C_QuoteRegex ||
      !C_QuoteRegex->regex)
  {
    return false;
  }

  FILE *fp_att = mutt_file_fopen(filename, "r");
  if (!fp_att)
    return false;

  char *inputline = mutt_mem_malloc(1024);
  bool found = false;
  while (!feof(fp_att))
  {
    fgets(inputline, 1024, fp_att);
    if (!mutt_is_quote_line(inputline, NULL) &&
        (regexec(C_AbortNoattachRegex->regex, inputline, 0, NULL, 0) == 0))
    {
      found = true;
      break;
    }
  }
  FREE(&inputline);
  mutt_file_fclose(&fp_att);
  return found;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int save_fcc ( struct Email *  msg, char *  fcc, size_t  fcc_len, struct Body *  clear_content, char *  pgpkeylist, SendFlags  flags, char **  finalpath  )

static

Save an Email to a 'sent mail' folder.

Parameters

[in]	msg	Email to save
[in]	fcc	Folder to save to (can be comma-separated list)
[in]	fcc_len	Length of fcc buffer
[in]	clear_content	Cleartext content of Email
[in]	pgpkeylist	List of pgp keys
[in]	flags	Send mode, see SendFlags
[out]	finalpath	Path of final folder

Return values

0	Success
-1	Error

Definition at line 1473 of file send.c.

{
  int rc = 0;
  struct Body *save_content = NULL;

  mutt_expand_path(fcc, fcc_len);

  /* Don't save a copy when we are in batch-mode, and the FCC
   * folder is on an IMAP server: This would involve possibly lots
   * of user interaction, which is not available in batch mode.
   *
   * Note: A patch to fix the problems with the use of IMAP servers
   * from non-curses mode is available from Brendan Cully.  However,
   * I'd like to think a bit more about this before including it.  */

#ifdef USE_IMAP
  if ((flags & SEND_BATCH) && (fcc[0] != '\0') && (imap_path_probe(fcc, NULL) == MUTT_IMAP))
  {
    fcc[0] = '\0';
    mutt_error(_("Fcc to an IMAP mailbox is not supported in batch mode"));
    return rc;
  }
#endif

  if (!(*fcc && mutt_str_strcmp("/dev/null", fcc)))
    return rc;

  struct Body *tmpbody = msg->content;
  struct Body *save_sig = NULL;
  struct Body *save_parts = NULL;

  if ((WithCrypto != 0) && (msg->security & (SEC_ENCRYPT | SEC_SIGN)) && C_FccClear)
  {
    msg->content = clear_content;
    msg->security &= ~(SEC_ENCRYPT | SEC_SIGN);
    mutt_env_free(&msg->content->mime_headers);
  }

  /* check to see if the user wants copies of all attachments */
  if (msg->content->type == TYPE_MULTIPART)
  {
    if ((WithCrypto != 0) && (msg->security & (SEC_ENCRYPT | SEC_SIGN)) &&
        ((mutt_str_strcmp(msg->content->subtype, "encrypted") == 0) ||
         (mutt_str_strcmp(msg->content->subtype, "signed") == 0)))
    {
      if ((clear_content->type == TYPE_MULTIPART) &&
          (query_quadoption(C_FccAttach, _("Save attachments in Fcc?")) == MUTT_NO))
      {
        if (!(msg->security & SEC_ENCRYPT) && (msg->security & SEC_SIGN))
        {
          /* save initial signature and attachments */
          save_sig = msg->content->parts->next;
          save_parts = clear_content->parts->next;
        }

        /* this means writing only the main part */
        msg->content = clear_content->parts;

        if (mutt_protect(msg, pgpkeylist) == -1)
        {
          /* we can't do much about it at this point, so
           * fallback to saving the whole thing to fcc */
          msg->content = tmpbody;
          save_sig = NULL;
          goto full_fcc;
        }

        save_content = msg->content;
      }
    }
    else
    {
      if (query_quadoption(C_FccAttach, _("Save attachments in Fcc?")) == MUTT_NO)
        msg->content = msg->content->parts;
    }
  }

full_fcc:
  if (msg->content)
  {
    /* update received time so that when storing to a mbox-style folder
     * the From_ line contains the current time instead of when the
     * message was first postponed.  */
    msg->received = time(NULL);
    rc = mutt_write_multiple_fcc(fcc, msg, NULL, false, NULL, finalpath);
    while (rc && !(flags & SEND_BATCH))
    {
      mutt_clear_error();
      int choice = mutt_multi_choice(
          /* L10N: Called when saving to $record or Fcc failed after sending.
             (r)etry tries the same mailbox again.
             alternate (m)ailbox prompts for a different mailbox to try.
             (s)kip aborts saving.  */
          _("Fcc failed. (r)etry, alternate (m)ailbox, or (s)kip? "),
          /* L10N: These correspond to the "Fcc failed" multi-choice prompt
             (r)etry, alternate (m)ailbox, or (s)kip.
             Any similarity to famous leaders of the FSF is coincidental.  */
          _("rms"));
      switch (choice)
      {
        case 2: /* alternate (m)ailbox */
          /* L10N: This is the prompt to enter an "alternate (m)ailbox" when the
             initial Fcc fails.  */
          rc = mutt_enter_fname(_("Fcc mailbox"), fcc, fcc_len, 1);
          if ((rc == -1) || (fcc[0] == '\0'))
          {
            rc = 0;
            break;
          }
          /* fall through */

        case 1: /* (r)etry */
          rc = mutt_write_multiple_fcc(fcc, msg, NULL, false, NULL, finalpath);
          break;

        case -1: /* abort */
        case 3:  /* (s)kip */
          rc = 0;
          break;
      }
    }
  }

  msg->content = tmpbody;

  if ((WithCrypto != 0) && save_sig)
  {
    /* cleanup the second signature structures */
    if (save_content->parts)
    {
      mutt_body_free(&save_content->parts->next);
      save_content->parts = NULL;
    }
    mutt_body_free(&save_content);

    /* restore old signature and attachments */
    msg->content->parts->next = save_sig;
    msg->content->parts->parts->next = save_parts;
  }
  else if ((WithCrypto != 0) && save_content)
  {
    /* destroy the new encrypted body. */
    mutt_body_free(&save_content);
  }

  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int postpone_message ( struct Email *  msg, struct Email *  cur, char *  fcc, SendFlags  flags  )

static

Save an Email for another day.

Parameters

msg	Email to postpone
cur	Current Email in the index
fcc	Folder for 'sent mail'
flags	Send mode, see SendFlags

Return values

0	Success
-1	Error

Definition at line 1631 of file send.c.

{
  char *pgpkeylist = NULL;
  char *encrypt_as = NULL;
  struct Body *clear_content = NULL;

  if (!(C_Postponed && *C_Postponed))
  {
    mutt_error(_("Cannot postpone.  $postponed is unset"));
    return -1;
  }

  if (msg->content->next)
    msg->content = mutt_make_multipart(msg->content);

  mutt_encode_descriptions(msg->content, true);

  if ((WithCrypto != 0) && C_PostponeEncrypt && (msg->security & SEC_ENCRYPT))
  {
    if (((WithCrypto & APPLICATION_PGP) != 0) && (msg->security & APPLICATION_PGP))
      encrypt_as = C_PgpDefaultKey;
    else if (((WithCrypto & APPLICATION_SMIME) != 0) && (msg->security & APPLICATION_SMIME))
      encrypt_as = C_SmimeDefaultKey;
    if (!(encrypt_as && *encrypt_as))
      encrypt_as = C_PostponeEncryptAs;

    if (encrypt_as && *encrypt_as)
    {
      bool is_signed = (msg->security & SEC_SIGN);
      if (is_signed)
        msg->security &= ~SEC_SIGN;

      pgpkeylist = mutt_str_strdup(encrypt_as);
      clear_content = msg->content;
      if (mutt_protect(msg, pgpkeylist) == -1)
      {
        if (is_signed)
          msg->security |= SEC_SIGN;
        FREE(&pgpkeylist);
        msg->content = mutt_remove_multipart(msg->content);
        decode_descriptions(msg->content);
        return -1;
      }

      if (is_signed)
        msg->security |= SEC_SIGN;
      FREE(&pgpkeylist);

      mutt_encode_descriptions(msg->content, false);
    }
  }

  /* make sure the message is written to the right part of a maildir
   * postponed folder.  */
  msg->read = false;
  msg->old = false;

  mutt_prepare_envelope(msg->env, false);
  mutt_env_to_intl(msg->env, NULL, NULL); /* Handle bad IDNAs the next time. */

  if (mutt_write_fcc(NONULL(C_Postponed), msg,
                     (cur && (flags & SEND_REPLY)) ? cur->env->message_id : NULL,
                     true, fcc, NULL) < 0)
  {
    if (clear_content)
    {
      mutt_body_free(&msg->content);
      msg->content = clear_content;
    }
    mutt_env_free(&msg->content->mime_headers); /* protected headers */
    msg->content = mutt_remove_multipart(msg->content);
    decode_descriptions(msg->content);
    mutt_unprepare_envelope(msg->env);
    return -1;
  }

  mutt_update_num_postponed();

  if (clear_content)
    mutt_body_free(&clear_content);

  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ci_send_message	(	SendFlags	flags,
		struct Email *	msg,
		const char *	tempfile,
		struct Context *	ctx,
		struct EmailList *	el
	)

Send an email.

Parameters

flags	Send mode, see SendFlags
msg	Template to use for new message
tempfile	File specified by -i or -H
ctx	Current mailbox
el	List of Emails to send

Return values

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

Definition at line 1726 of file send.c.

{
  char buf[1024];
  char fcc[PATH_MAX] = ""; /* where to copy this message */
  FILE *fp_tmp = NULL;
  struct Body *pbody = NULL;
  int i;
  bool killfrom = false;
  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_signas = NULL;
  char *smime_signas = NULL;
  const char *tag = NULL;
  char *err = NULL;
  char *ctype = NULL;
  char *finalpath = NULL;
  struct EmailNode *en = NULL;
  struct Email *cur = NULL;

  if (el)
    en = STAILQ_FIRST(el);
  if (en)
    cur = STAILQ_NEXT(en, entries) ? en->email : NULL;

  int rc = -1;

#ifdef USE_NNTP
  if (flags & SEND_NEWS)
    OptNewsSend = true;
  else
    OptNewsSend = false;
#endif

  if (!flags && !msg && (C_Recall != MUTT_NO) &&
      mutt_num_postponed(ctx ? ctx->mailbox : NULL, true))
  {
    /* If the user is composing a new message, check to see if there
     * are any postponed messages first.  */
    enum QuadOption ans =
        query_quadoption(C_Recall, _("Recall postponed message?"));
    if (ans == MUTT_ABORT)
      return rc;

    if (ans == MUTT_YES)
      flags |= SEND_POSTPONED;
  }

  if (flags & SEND_POSTPONED)
  {
    if (WithCrypto & APPLICATION_PGP)
      pgp_signas = mutt_str_strdup(C_PgpSignAs);
    if (WithCrypto & APPLICATION_SMIME)
      smime_signas = mutt_str_strdup(C_SmimeSignAs);
  }

  /* 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 (!msg)
  {
    msg = mutt_email_new();

    if (flags == SEND_POSTPONED)
    {
      rc = mutt_get_postponed(ctx, msg, &cur, fcc, sizeof(fcc));
      if (rc < 0)
      {
        flags = SEND_POSTPONED;
        goto cleanup;
      }
      flags = rc;
#ifdef USE_NNTP
      /* If postponed message is a news article, it have
       * a "Newsgroups:" header line, then set appropriate flag.  */
      if (msg->env->newsgroups)
      {
        flags |= SEND_NEWS;
        OptNewsSend = true;
      }
      else
      {
        flags &= ~SEND_NEWS;
        OptNewsSend = false;
      }
#endif
    }

    if (flags & (SEND_POSTPONED | SEND_RESEND))
    {
      fp_tmp = mutt_file_fopen(msg->content->filename, "a+");
      if (!fp_tmp)
      {
        mutt_perror(msg->content->filename);
        goto cleanup;
      }
    }

    if (!msg->env)
      msg->env = mutt_env_new();
  }

  /* Parse and use an eventual list-post header */
  if ((flags & SEND_LIST_REPLY) && cur && cur->env && cur->env->list_post)
  {
    /* Use any list-post header as a template */
    url_parse_mailto(msg->env, NULL, cur->env->list_post);
    /* We don't let them set the sender's address. */
    mutt_addr_free(&msg->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 = msg->content; /* don't kill command-line attachments */
      msg->content = pbody;

      ctype = mutt_str_strdup(C_ContentType);
      if (!ctype)
        ctype = mutt_str_strdup("text/plain");
      mutt_parse_content_type(ctype, msg->content);
      FREE(&ctype);
      msg->content->unlink = true;
      msg->content->use_disp = false;
      msg->content->disposition = DISP_INLINE;

      if (!tempfile)
      {
        mutt_mktemp(buf, sizeof(buf));
        fp_tmp = mutt_file_fopen(buf, "w+");
        msg->content->filename = mutt_str_strdup(buf);
      }
      else
      {
        fp_tmp = mutt_file_fopen(tempfile, "a+");
        msg->content->filename = mutt_str_strdup(tempfile);
      }
    }
    else
      fp_tmp = mutt_file_fopen(msg->content->filename, "a+");

    if (!fp_tmp)
    {
      mutt_debug(LL_DEBUG1, "can't create tempfile %s (errno=%d)\n",
                 msg->content->filename, errno);
      mutt_perror(msg->content->filename);
      goto cleanup;
    }
  }

  /* this is handled here so that the user can match ~f in send-hook */
  if (cur && C_ReverseName && !(flags & (SEND_POSTPONED | SEND_RESEND)))
  {
    /* we shouldn't have to worry about freeing 'msg->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.
     *
     * 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 (msg->env->from)
    {
      mutt_debug(5, "msg->env->from before set_reverse_name: %s\n",
                 msg->env->from->mailbox);
    }
    msg->env->from = set_reverse_name(cur->env);
  }
  if (cur && C_ReplyWithXorig && !(flags & (SEND_POSTPONED | SEND_RESEND | SEND_FORWARD)))
  {
    /* We shouldn't have to worry about freeing 'msg->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 'msg->env->from',
     * then it theoretically comes from C_ReverseName handling, and we don't use
     * the 'X-Orig-To header'.  */
    if (cur->env->x_original_to && !msg->env->from)
    {
      msg->env->from = mutt_addr_copy(cur->env->x_original_to);
      mutt_debug(5, "msg->env->from extracted from X-Original-To: header: %s\n",
                 msg->env->from->mailbox);
    }
  }

  if (!(flags & (SEND_POSTPONED | SEND_RESEND)) &&
      !((flags & SEND_DRAFT_FILE) && C_ResumeDraftFiles))
  {
    if ((flags & (SEND_REPLY | SEND_FORWARD | SEND_TO_SENDER)) && ctx &&
        (envelope_defaults(msg->env, ctx->mailbox, el, flags) == -1))
    {
      goto cleanup;
    }

    if (C_Hdrs)
      process_user_recips(msg->env);

    /* Expand aliases and remove duplicates/crossrefs */
    mutt_expand_aliases_env(msg->env);

    if (flags & SEND_REPLY)
      mutt_fix_reply_recipients(msg->env);

#ifdef USE_NNTP
    if ((flags & SEND_NEWS) && ctx && (ctx->mailbox->magic == MUTT_NNTP) &&
        !msg->env->newsgroups)
    {
      msg->env->newsgroups =
          mutt_str_strdup(((struct NntpMboxData *) ctx->mailbox->mdata)->group);
    }
#endif

    if (!(flags & (SEND_MAILX | SEND_BATCH)) &&
        !(C_Autoedit && C_EditHeaders) && !((flags & SEND_REPLY) && C_FastReply))
    {
      if (edit_envelope(msg->env, flags) == -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 */

    if (!msg->env->from)
    {
      msg->env->from = mutt_default_from();
      killfrom = true;
    }

    if ((flags & SEND_REPLY) && cur)
    {
      /* change setting based upon message we are replying to */
      mutt_message_hook(ctx ? ctx->mailbox : NULL, 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.  */
      msg->replied = true;
    }

    /* change settings based upon recipients */

    mutt_message_hook(NULL, msg, 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.  */
    msg->replied = false;

    if (!(flags & SEND_KEY))
    {
      if (C_TextFlowed && (msg->content->type == TYPE_TEXT) &&
          (mutt_str_strcasecmp(msg->content->subtype, "plain") == 0))
      {
        mutt_param_set(&msg->content->parameter, "format", "flowed");
      }
    }

    /* $use_from and/or $from might have changed in a send-hook */
    if (killfrom)
    {
      mutt_addr_free(&msg->env->from);
      if (C_UseFrom && !(flags & (SEND_POSTPONED | SEND_RESEND)))
        msg->env->from = mutt_default_from();
      killfrom = false;
    }

    if (C_Hdrs)
      process_user_header(msg->env);

    if (flags & SEND_BATCH)
      mutt_file_copy_stream(stdin, fp_tmp);

    if (C_SigOnTop && !(flags & (SEND_MAILX | SEND_KEY | SEND_BATCH)) &&
        C_Editor && (mutt_str_strcmp(C_Editor, "builtin") != 0))
    {
      append_signature(fp_tmp);
    }

    /* include replies/forwarded messages, unless we are given a template */
    if (!tempfile && (ctx || !(flags & (SEND_REPLY | SEND_FORWARD))) &&
        (generate_body(fp_tmp, msg, flags, ctx->mailbox, el) == -1))
    {
      goto cleanup;
    }

    if (!C_SigOnTop && !(flags & (SEND_MAILX | SEND_KEY | SEND_BATCH)) &&
        C_Editor && (mutt_str_strcmp(C_Editor, "builtin") != 0))
    {
      append_signature(fp_tmp);
    }
  }

  /* 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, msg, MUTT_SEND2_HOOK);

  /* wait until now to set the real name portion of our return address so
   * that $realname can be set in a send-hook */
  if (msg->env->from && !msg->env->from->personal && !(flags & (SEND_RESEND | SEND_POSTPONED)))
    msg->env->from->personal = mutt_str_strdup(C_Realname);

  if (!(((WithCrypto & APPLICATION_PGP) != 0) && (flags & SEND_KEY)))
    mutt_file_fclose(&fp_tmp);

  if (flags & SEND_MAILX)
  {
    if (mutt_builtin_editor(msg->content->filename, msg, cur) == -1)
      goto cleanup;
  }
  else if (!(flags & SEND_BATCH))
  {
    struct stat st;
    time_t mtime = mutt_file_decrease_mtime(msg->content->filename, NULL);

    mutt_update_encoding(msg->content);

    /* 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 $autoedit 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_EditHeaders && C_Autoedit) ||
         (query_quadoption(C_ForwardEdit, _("Edit forwarded message?")) == MUTT_YES)))
    {
      /* If the this isn't a text message, look for a mailcap edit command */
      if (mutt_needs_mailcap(msg->content))
      {
        if (!mutt_edit_attachment(msg->content))
          goto cleanup;
      }
      else if (!C_Editor || (mutt_str_strcmp("builtin", C_Editor) == 0))
        mutt_builtin_editor(msg->content->filename, msg, cur);
      else if (C_EditHeaders)
      {
        mutt_env_to_local(msg->env);
        mutt_edit_headers(C_Editor, msg->content->filename, msg, fcc, sizeof(fcc));
        mutt_env_to_intl(msg->env, NULL, NULL);
      }
      else
      {
        mutt_edit_file(C_Editor, msg->content->filename);
        if (stat(msg->content->filename, &st) == 0)
        {
          if (mtime != st.st_mtime)
            fix_end_of_file(msg->content->filename);
        }
        else
          mutt_perror(msg->content->filename);
      }

      /* If using format=flowed, perform space stuffing.  Avoid stuffing when
       * recalling a postponed message where the stuffing was already
       * performed.  If it has already been performed, the format=flowed
       * parameter will be present.  */
      if (C_TextFlowed && (msg->content->type == TYPE_TEXT) &&
          (mutt_str_strcasecmp("plain", msg->content->subtype) == 0))
      {
        char *p = mutt_param_get(&msg->content->parameter, "format");
        if (mutt_str_strcasecmp("flowed", p) != 0)
          rfc3676_space_stuff(msg);
      }

      mutt_message_hook(NULL, msg, MUTT_SEND2_HOOK);
    }

    if (!(flags & (SEND_POSTPONED | SEND_FORWARD | SEND_KEY | SEND_RESEND | SEND_DRAFT_FILE)))
    {
      if (stat(msg->content->filename, &st) == 0)
      {
        /* if the file was not modified, bail out now */
        if ((mtime == st.st_mtime) && !msg->content->next &&
            (query_quadoption(C_AbortUnmodified,
                              _("Abort unmodified message?")) == MUTT_YES))
        {
          mutt_message(_("Aborted unmodified message"));
          goto cleanup;
        }
      }
      else
        mutt_perror(msg->content->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 (msg->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 mailx mode
   * 6) we are in batch mode
   *
   * 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) && (msg->security == 0) &&
      !(flags & (SEND_BATCH | SEND_MAILX | SEND_POSTPONED | SEND_RESEND)))
  {
    if (C_CryptAutosign)
      msg->security |= SEC_SIGN;
    if (C_CryptAutoencrypt)
      msg->security |= SEC_ENCRYPT;
    if (C_CryptReplyencrypt && cur && (cur->security & SEC_ENCRYPT))
      msg->security |= SEC_ENCRYPT;
    if (C_CryptReplysign && cur && (cur->security & SEC_SIGN))
      msg->security |= SEC_SIGN;
    if (C_CryptReplysignencrypted && cur && (cur->security & SEC_ENCRYPT))
      msg->security |= SEC_SIGN;
    if (((WithCrypto & APPLICATION_PGP) != 0) &&
        ((msg->security & (SEC_ENCRYPT | SEC_SIGN)) || C_CryptOpportunisticEncrypt))
    {
      if (C_PgpAutoinline)
        msg->security |= SEC_INLINE;
      if (C_PgpReplyinline && cur && (cur->security & SEC_INLINE))
        msg->security |= SEC_INLINE;
    }

    if (msg->security || C_CryptOpportunisticEncrypt)
    {
      /* 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 (cur)
      {
        if (((WithCrypto & APPLICATION_PGP) != 0) && C_CryptAutopgp &&
            (cur->security & APPLICATION_PGP))
        {
          msg->security |= APPLICATION_PGP;
        }
        else if (((WithCrypto & APPLICATION_SMIME) != 0) && C_CryptAutosmime &&
                 (cur->security & APPLICATION_SMIME))
        {
          msg->security |= APPLICATION_SMIME;
        }
      }

      /* No crypto mechanism selected? Use availability + smime_is_default
       * for the decision.  */
      if (!(msg->security & (APPLICATION_SMIME | APPLICATION_PGP)))
      {
        if (((WithCrypto & APPLICATION_SMIME) != 0) && C_CryptAutosmime && C_SmimeIsDefault)
        {
          msg->security |= APPLICATION_SMIME;
        }
        else if (((WithCrypto & APPLICATION_PGP) != 0) && C_CryptAutopgp)
        {
          msg->security |= APPLICATION_PGP;
        }
        else if (((WithCrypto & APPLICATION_SMIME) != 0) && C_CryptAutosmime)
        {
          msg->security |= APPLICATION_SMIME;
        }
      }
    }

    /* opportunistic encrypt relies on SMIME or PGP already being selected */
    if (C_CryptOpportunisticEncrypt)
    {
      /* If something has already enabled encryption, e.g. C_CryptAutoencrypt
       * or C_CryptReplyencrypt, then don't enable opportunistic encrypt for
       * the message.  */
      if (!(msg->security & SEC_ENCRYPT))
      {
        msg->security |= SEC_OPPENCRYPT;
        crypt_opportunistic_encrypt(msg);
      }
    }

    /* No permissible mechanisms found.  Don't sign or encrypt. */
    if (!(msg->security & (APPLICATION_SMIME | APPLICATION_PGP)))
      msg->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 (msg->security && !crypt_has_module_backend(msg->security))
  {
    mutt_error(_(
        "No crypto backend configured.  Disabling message security setting."));
    msg->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 */

  if (!fcc[0] && !(flags & SEND_POSTPONED_FCC) && (!(flags & SEND_BATCH) || (C_Copy & 0x1)))
  {
    /* set the default FCC */
    if (!msg->env->from)
    {
      msg->env->from = mutt_default_from();
      killfrom = true; /* no need to check $use_from because if the user specified
                       a from address it would have already been set by now */
    }
    mutt_select_fcc(fcc, sizeof(fcc), msg);
    if (killfrom)
    {
      mutt_addr_free(&msg->env->from);
    }
  }

  mutt_update_encoding(msg->content);

  if (!(flags & (SEND_MAILX | SEND_BATCH)))
  {
  main_loop:

    mutt_pretty_mailbox(fcc, sizeof(fcc));
    i = mutt_compose_menu(msg, fcc, sizeof(fcc), cur,
                          ((flags & SEND_NO_FREE_HEADER) ? MUTT_COMPOSE_NOFREEHEADER : 0));
    if (i == -1)
    {
/* abort */
#ifdef USE_NNTP
      if (flags & SEND_NEWS)
        mutt_message(_("Article not posted"));
      else
#endif
        mutt_message(_("Mail not sent"));
      goto cleanup;
    }
    else if (i == 1)
    {
      if (postpone_message(msg, cur, fcc, flags) != 0)
        goto main_loop;
      mutt_message(_("Message postponed"));
      rc = 1;
      goto cleanup;
    }
  }

#ifdef USE_NNTP
  if (!(flags & SEND_NEWS))
#endif
    if ((mutt_addr_has_recips(msg->env->to) == 0) &&
        (mutt_addr_has_recips(msg->env->cc) == 0) &&
        (mutt_addr_has_recips(msg->env->bcc) == 0))
    {
      if (!(flags & SEND_BATCH))
      {
        mutt_error(_("No recipients specified"));
        goto main_loop;
      }
      else
      {
        puts(_("No recipients specified"));
        goto cleanup;
      }
    }

  if (mutt_env_to_intl(msg->env, &tag, &err))
  {
    mutt_error(_("Bad IDN in '%s': '%s'"), tag, err);
    FREE(&err);
    if (!(flags & SEND_BATCH))
      goto main_loop;
    else
      goto cleanup;
  }

  if (!msg->env->subject && !(flags & SEND_BATCH) &&
      (query_quadoption(C_AbortNosubject, _("No subject, abort sending?")) != MUTT_NO))
  {
    /* if the abort is automatic, print an error message */
    if (C_AbortNosubject == MUTT_YES)
      mutt_error(_("No subject specified"));
    goto main_loop;
  }
#ifdef USE_NNTP
  if ((flags & SEND_NEWS) && !msg->env->subject)
  {
    mutt_error(_("No subject specified"));
    goto main_loop;
  }

  if ((flags & SEND_NEWS) && !msg->env->newsgroups)
  {
    mutt_error(_("No newsgroup specified"));
    goto main_loop;
  }
#endif

  if (!(flags & SEND_BATCH) && (C_AbortNoattach != MUTT_NO) &&
      !msg->content->next && (msg->content->type == TYPE_TEXT) &&
      (mutt_str_strcasecmp(msg->content->subtype, "plain") == 0) &&
      search_attach_keyword(msg->content->filename) &&
      (query_quadoption(C_AbortNoattach,
                        _("No attachments, cancel sending?")) != MUTT_NO))
  {
    /* if the abort is automatic, print an error message */
    if (C_AbortNoattach == MUTT_YES)
    {
      mutt_error(_("Message contains text matching "
                   "\"$abort_noattach_regex\". Not sending."));
    }
    goto main_loop;
  }

  if (msg->content->next)
    msg->content = mutt_make_multipart(msg->content);

  /* 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(msg->content, true);

  /* 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 (msg->security & (SEC_ENCRYPT | SEC_SIGN))
    {
      /* save the decrypted attachments */
      clear_content = msg->content;

      if ((crypt_get_keys(msg, &pgpkeylist, 0) == -1) ||
          (mutt_protect(msg, pgpkeylist) == -1))
      {
        msg->content = mutt_remove_multipart(msg->content);

        FREE(&pgpkeylist);

        decode_descriptions(msg->content);
        goto main_loop;
      }
      mutt_encode_descriptions(msg->content, false);
    }

    /* at this point, msg->content 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 && (msg->content != clear_content) && (msg->content->parts != clear_content))
      free_clear_content = true;
  }

  if (!OptNoCurses && !(flags & SEND_MAILX))
    mutt_message(_("Sending message..."));

  mutt_prepare_envelope(msg->env, true);

  i = send_message(msg);
  if (i < 0)
  {
    if (!(flags & SEND_BATCH))
    {
      if (!WithCrypto)
        ;
      else if ((msg->security & SEC_ENCRYPT) ||
               ((msg->security & SEC_SIGN) && (msg->content->type == TYPE_APPLICATION)))
      {
        mutt_body_free(&msg->content); /* destroy PGP data */
        msg->content = clear_content;  /* restore clear text. */
      }
      else if ((msg->security & SEC_SIGN) && (msg->content->type == TYPE_MULTIPART))
      {
        mutt_body_free(&msg->content->parts->next); /* destroy sig */
        msg->content = mutt_remove_multipart(msg->content);
      }

      FREE(&pgpkeylist);
      mutt_env_free(&msg->content->mime_headers); /* protected headers */
      msg->content = mutt_remove_multipart(msg->content);
      decode_descriptions(msg->content);
      mutt_unprepare_envelope(msg->env);
      FREE(&finalpath);
      goto main_loop;
    }
    else
    {
      puts(_("Could not send the message"));
      goto cleanup;
    }
  }

  save_fcc(msg, fcc, sizeof(fcc), clear_content, pgpkeylist, flags, &finalpath);

  if (!OptNoCurses && !(flags & SEND_MAILX))
  {
    mutt_message(i != 0 ? _("Sending in background") :
                          (flags & SEND_NEWS) ? _("Article posted") : /* USE_NNTP */
                              _("Mail sent"));
#ifdef USE_NOTMUCH
    if (C_NmRecord)
      nm_record_message(ctx ? ctx->mailbox : NULL, finalpath, 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 (cur && ctx)
      mutt_set_flag(ctx->mailbox, cur, MUTT_REPLIED, is_reply(cur, msg));
    else if (!(flags & SEND_POSTPONED) && ctx && ctx->mailbox &&
             (ctx->mailbox->msg_tagged != 0))
    {
      STAILQ_FOREACH(en, el, entries)
      {
        mutt_set_flag(ctx->mailbox, en->email, MUTT_REPLIED, is_reply(en->email, msg));
      }
    }
  }

  rc = 0;

cleanup:

  if (flags & SEND_POSTPONED)
  {
    if (WithCrypto & APPLICATION_PGP)
    {
      FREE(&C_PgpSignAs);
      C_PgpSignAs = pgp_signas;
    }
    if (WithCrypto & APPLICATION_SMIME)
    {
      FREE(&C_SmimeSignAs);
      C_SmimeSignAs = smime_signas;
    }
  }

  mutt_file_fclose(&fp_tmp);
  if (!(flags & SEND_NO_FREE_HEADER))
    mutt_email_free(&msg);

  FREE(&finalpath);
  return rc;
}

Here is the caller graph for this function:

Variable Documentation

unsigned char C_AbortNoattach

Config: Abort sending the email if attachments are missing.

Definition at line 84 of file send.c.

struct Regex* C_AbortNoattachRegex

Config: Regex to match text indicating attachments are expected.

Definition at line 85 of file send.c.

unsigned char C_AbortNosubject

Config: Abort creating the email if subject is missing.

Definition at line 86 of file send.c.

unsigned char C_AbortUnmodified

Config: Abort the sending if the message hasn't been edited.

Definition at line 87 of file send.c.

bool C_AskFollowUp

Config: (nntp) Ask the user for follow-up groups before editing.

Definition at line 88 of file send.c.

bool C_AskXCommentTo

Config: (nntp) Ask the user for the 'X-Comment-To' field before editing.

Definition at line 89 of file send.c.

char* C_ContentType

Config: Default "Content-Type" for newly composed messages.

Definition at line 90 of file send.c.

bool C_CryptAutoencrypt

Config: Automatically PGP encrypt all outgoing mail.

Definition at line 91 of file send.c.

bool C_CryptAutopgp

Config: Allow automatic PGP functions.

Definition at line 92 of file send.c.

bool C_CryptAutosign

Config: Automatically PGP sign all outgoing mail.

Definition at line 93 of file send.c.

bool C_CryptAutosmime

Config: Allow automatic SMIME functions.

Definition at line 94 of file send.c.

bool C_CryptReplyencrypt

Config: Encrypt replies to encrypted messages.

Definition at line 95 of file send.c.

bool C_CryptReplysign

Config: Sign replies to signed messages.

Definition at line 96 of file send.c.

bool C_CryptReplysignencrypted

Config: Sign replies to encrypted messages.

Definition at line 97 of file send.c.

char* C_EmptySubject

Config: Subject to use when replying to an email with none.

Definition at line 98 of file send.c.

bool C_FastReply

Config: Don't prompt for the recipients and subject when replying/forwarding.

Definition at line 99 of file send.c.

unsigned char C_FccAttach

Config: Save send message with all their attachments.

Definition at line 100 of file send.c.

bool C_FccClear

Config: Save sent messages unencrypted and unsigned.

Definition at line 101 of file send.c.

bool C_FollowupTo

Config: Add the 'Mail-Followup-To' header is generated when sending mail.

Definition at line 102 of file send.c.

char* C_ForwardAttributionIntro

Config: Prefix message for forwarded messages.

Definition at line 103 of file send.c.

char* C_ForwardAttributionTrailer

Config: Suffix message for forwarded messages.

Definition at line 104 of file send.c.

unsigned char C_ForwardEdit

Config: Automatically start the editor when forwarding a message.

Definition at line 105 of file send.c.

char* C_ForwardFormat

Config: printf-like format string to control the subject when forwarding a message.

Definition at line 106 of file send.c.

bool C_ForwardReferences

Config: Set the 'In-Reply-To' and 'References' headers when forwarding a message.

Definition at line 107 of file send.c.

bool C_Hdrs

Config: Add custom headers to outgoing mail.

Definition at line 108 of file send.c.

unsigned char C_HonorFollowupTo

Config: Honour the 'Mail-Followup-To' header when group replying.

Definition at line 109 of file send.c.

bool C_IgnoreListReplyTo

Config: Ignore the 'Reply-To' header when using <reply> on a mailing list.

Definition at line 110 of file send.c.

unsigned char C_Include

Config: Include a copy of the email that's being replied to.

Definition at line 111 of file send.c.

bool C_Metoo

Config: Remove the user's address from the list of recipients.

Definition at line 112 of file send.c.

bool C_NmRecord

Config: (notmuch) If the 'record' mailbox (sent mail) should be indexed.

Definition at line 113 of file send.c.

bool C_PgpReplyinline

Config: Reply using old-style inline PGP messages (not recommended)

Definition at line 114 of file send.c.

char* C_PostIndentString

Config: Suffix message to add after reply text.

Definition at line 115 of file send.c.

bool C_PostponeEncrypt

Config: Self-encrypt postponed messages.

Definition at line 116 of file send.c.

char* C_PostponeEncryptAs

Config: Fallback encryption key for postponed messages.

Definition at line 117 of file send.c.

unsigned char C_Recall

Config: Recall postponed mesaages when asked to compose a message.

Definition at line 118 of file send.c.

bool C_ReplySelf

Config: Really reply to yourself, when replying to your own email.

Definition at line 119 of file send.c.

unsigned char C_ReplyTo

Config: Address to use as a 'Reply-To' header.

Definition at line 120 of file send.c.

bool C_ReplyWithXorig

Config: Create 'From' header from 'X-Original-To' header.

Definition at line 121 of file send.c.

bool C_ReverseName

Config: Set the 'From' from the address the email was sent to.

Definition at line 122 of file send.c.

bool C_ReverseRealname

Config: Set the 'From' from the full 'To' address the email was sent to.

Definition at line 123 of file send.c.

bool C_SigDashes

Config: Insert '– ' before the signature.

Definition at line 124 of file send.c.

char* C_Signature

Config: File containing a signature to append to all mail.

Definition at line 125 of file send.c.

bool C_SigOnTop

Config: Insert the signature before the quoted text.

Definition at line 126 of file send.c.

bool C_UseFrom

Config: Set the 'From' header for outgoing mail.

Definition at line 127 of file send.c.