NeoMutt  2018-07-16 +2481-68dcde
Teaching an old dog new tricks
DOXYGEN
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. More...
 
#define SEND_REPLY   (1 << 0)
 Reply to sender. More...
 
#define SEND_GROUP_REPLY   (1 << 1)
 Reply to all. More...
 
#define SEND_LIST_REPLY   (1 << 2)
 Reply to mailing list. More...
 
#define SEND_FORWARD   (1 << 3)
 Forward email. More...
 
#define SEND_POSTPONED   (1 << 4)
 Recall a postponed email. More...
 
#define SEND_BATCH   (1 << 5)
 Send email in batch mode (without user interaction) More...
 
#define SEND_MAILX   (1 << 6)
 Send email in Mailx compatibility mode. More...
 
#define SEND_KEY   (1 << 7)
 Mail a PGP public key. More...
 
#define SEND_RESEND   (1 << 8)
 Reply using the current email as a template. More...
 
#define SEND_POSTPONED_FCC   (1 << 9)
 Used by mutt_get_postponed() to signal that the x-mutt-fcc header field was present. More...
 
#define SEND_NO_FREE_HEADER   (1 << 10)
 Used by the -E flag. More...
 
#define SEND_DRAFT_FILE   (1 << 11)
 Used by the -H flag. More...
 
#define SEND_TO_SENDER   (1 << 12)
 Compose new email to sender. More...
 
#define SEND_GROUP_CHAT_REPLY   (1 << 13)
 Reply to all recipients preserving To/Cc. More...
 
#define SEND_NEWS   (1 << 14)
 Reply to a news article. More...
 

Typedefs

typedef uint16_t SendFlags
 Flags for ci_send_message(), e.g. SEND_REPLY. More...
 

Functions

int ci_send_message (SendFlags flags, struct Email *e_templ, const char *tempfile, struct Context *ctx, struct EmailList *el)
 Send an email. More...
 
void mutt_add_to_reference_headers (struct Envelope *env, struct Envelope *curenv)
 Generate references for a reply email. More...
 
struct Addressmutt_default_from (void)
 Get a default 'from' Address. More...
 
int mutt_edit_address (struct AddressList *al, const char *field, bool expand_aliases)
 Edit an email address. More...
 
void mutt_encode_descriptions (struct Body *b, bool recurse)
 rfc2047 encode the content-descriptions More...
 
int mutt_fetch_recips (struct Envelope *out, struct Envelope *in, SendFlags flags)
 Generate recpients for a reply email. More...
 
void mutt_fix_reply_recipients (struct Envelope *env)
 Remove duplicate recipients. 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...
 
void mutt_make_attribution (struct Mailbox *m, struct Email *e, FILE *fp_out)
 Add "on DATE, PERSON wrote" header. More...
 
void mutt_make_forward_subject (struct Envelope *env, struct Mailbox *m, struct Email *e)
 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_make_post_indent (struct Mailbox *m, struct Email *e, FILE *fp_out)
 Add suffix to replied email text. More...
 
struct Addressmutt_remove_xrefs (struct Address *a, struct Address *b)
 
int mutt_resend_message (FILE *fp, struct Context *ctx, struct Email *e_cur)
 Resend an email. More...
 
void mutt_set_followup_to (struct Envelope *e)
 Set followup-to field. More...
 

Variables

unsigned char C_AbortNoattach
 Config: Abort sending the email if attachments are missing. More...
 
struct RegexC_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_FccBeforeSend
 Config: Save FCCs before sending the message. 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
  • Richard Russon

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 86 of file send.h.

◆ SEND_REPLY

#define SEND_REPLY   (1 << 0)

Reply to sender.

Definition at line 87 of file send.h.

◆ SEND_GROUP_REPLY

#define SEND_GROUP_REPLY   (1 << 1)

Reply to all.

Definition at line 88 of file send.h.

◆ SEND_LIST_REPLY

#define SEND_LIST_REPLY   (1 << 2)

Reply to mailing list.

Definition at line 89 of file send.h.

◆ SEND_FORWARD

#define SEND_FORWARD   (1 << 3)

Forward email.

Definition at line 90 of file send.h.

◆ SEND_POSTPONED

#define SEND_POSTPONED   (1 << 4)

Recall a postponed email.

Definition at line 91 of file send.h.

◆ SEND_BATCH

#define SEND_BATCH   (1 << 5)

Send email in batch mode (without user interaction)

Definition at line 92 of file send.h.

◆ SEND_MAILX

#define SEND_MAILX   (1 << 6)

Send email in Mailx compatibility mode.

Definition at line 93 of file send.h.

◆ SEND_KEY

#define SEND_KEY   (1 << 7)

Mail a PGP public key.

Definition at line 94 of file send.h.

◆ SEND_RESEND

#define SEND_RESEND   (1 << 8)

Reply using the current email as a template.

Definition at line 95 of file send.h.

◆ SEND_POSTPONED_FCC

#define SEND_POSTPONED_FCC   (1 << 9)

Used by mutt_get_postponed() to signal that the x-mutt-fcc header field was present.

Definition at line 96 of file send.h.

◆ SEND_NO_FREE_HEADER

#define SEND_NO_FREE_HEADER   (1 << 10)

Used by the -E flag.

Definition at line 97 of file send.h.

◆ SEND_DRAFT_FILE

#define SEND_DRAFT_FILE   (1 << 11)

Used by the -H flag.

Definition at line 98 of file send.h.

◆ SEND_TO_SENDER

#define SEND_TO_SENDER   (1 << 12)

Compose new email to sender.

Definition at line 99 of file send.h.

◆ SEND_GROUP_CHAT_REPLY

#define SEND_GROUP_CHAT_REPLY   (1 << 13)

Reply to all recipients preserving To/Cc.

Definition at line 100 of file send.h.

◆ SEND_NEWS

#define SEND_NEWS   (1 << 14)

Reply to a news article.

Definition at line 101 of file send.h.

Typedef Documentation

◆ SendFlags

typedef uint16_t SendFlags

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

Definition at line 85 of file send.h.

Function Documentation

◆ ci_send_message()

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

Send an email.

Parameters
flagsSend mode, see SendFlags
e_templTemplate to use for new message
tempfileFile specified by -i or -H
ctxCurrent mailbox
elList of Emails to send
Return values
0Message was successfully sent
-1Message was aborted or an error occurred
1Message was postponed

Definition at line 1837 of file send.c.

1839 {
1840  char buf[1024];
1841  char fcc[PATH_MAX] = { 0 }; /* where to copy this message */
1842  FILE *fp_tmp = NULL;
1843  struct Body *pbody = NULL;
1844  int i;
1845  bool free_clear_content = false;
1846 
1847  struct Body *clear_content = NULL;
1848  char *pgpkeylist = NULL;
1849  /* save current value of "pgp_sign_as" and "smime_default_key" */
1850  char *pgp_signas = NULL;
1851  char *smime_signas = NULL;
1852  const char *tag = NULL;
1853  char *err = NULL;
1854  char *ctype = NULL;
1855  char *finalpath = NULL;
1856  struct EmailNode *en = NULL;
1857  struct Email *e_cur = NULL;
1858 
1859  if (el)
1860  en = STAILQ_FIRST(el);
1861  if (en)
1862  e_cur = STAILQ_NEXT(en, entries) ? NULL : en->email;
1863 
1864  int rc = -1;
1865 
1866 #ifdef USE_NNTP
1867  if (flags & SEND_NEWS)
1868  OptNewsSend = true;
1869  else
1870  OptNewsSend = false;
1871 #endif
1872 
1873  if (!flags && !e_templ && (C_Recall != MUTT_NO) &&
1874  mutt_num_postponed(ctx ? ctx->mailbox : NULL, true))
1875  {
1876  /* If the user is composing a new message, check to see if there
1877  * are any postponed messages first. */
1878  enum QuadOption ans =
1879  query_quadoption(C_Recall, _("Recall postponed message?"));
1880  if (ans == MUTT_ABORT)
1881  return rc;
1882 
1883  if (ans == MUTT_YES)
1884  flags |= SEND_POSTPONED;
1885  }
1886 
1887  if (flags & SEND_POSTPONED)
1888  {
1890  pgp_signas = mutt_str_strdup(C_PgpSignAs);
1892  smime_signas = mutt_str_strdup(C_SmimeSignAs);
1893  }
1894 
1895  /* Delay expansion of aliases until absolutely necessary--shouldn't
1896  * be necessary unless we are prompting the user or about to execute a
1897  * send-hook. */
1898 
1899  if (!e_templ)
1900  {
1901  e_templ = email_new();
1902 
1903  if (flags == SEND_POSTPONED)
1904  {
1905  rc = mutt_get_postponed(ctx, e_templ, &e_cur, fcc, sizeof(fcc));
1906  if (rc < 0)
1907  {
1908  flags = SEND_POSTPONED;
1909  goto cleanup;
1910  }
1911  flags = rc;
1912 #ifdef USE_NNTP
1913  /* If postponed message is a news article, it have
1914  * a "Newsgroups:" header line, then set appropriate flag. */
1915  if (e_templ->env->newsgroups)
1916  {
1917  flags |= SEND_NEWS;
1918  OptNewsSend = true;
1919  }
1920  else
1921  {
1922  flags &= ~SEND_NEWS;
1923  OptNewsSend = false;
1924  }
1925 #endif
1926  }
1927 
1928  if (flags & (SEND_POSTPONED | SEND_RESEND))
1929  {
1930  fp_tmp = mutt_file_fopen(e_templ->content->filename, "a+");
1931  if (!fp_tmp)
1932  {
1933  mutt_perror(e_templ->content->filename);
1934  goto cleanup;
1935  }
1936  }
1937 
1938  if (!e_templ->env)
1939  e_templ->env = mutt_env_new();
1940  }
1941 
1942  /* Parse and use an eventual list-post header */
1943  if ((flags & SEND_LIST_REPLY) && e_cur && e_cur->env && e_cur->env->list_post)
1944  {
1945  /* Use any list-post header as a template */
1946  mutt_parse_mailto(e_templ->env, NULL, e_cur->env->list_post);
1947  /* We don't let them set the sender's address. */
1948  mutt_addrlist_clear(&e_templ->env->from);
1949  }
1950 
1951  if (!(flags & (SEND_KEY | SEND_POSTPONED | SEND_RESEND)))
1952  {
1953  /* When SEND_DRAFT_FILE is set, the caller has already
1954  * created the "parent" body structure. */
1955  if (!(flags & SEND_DRAFT_FILE))
1956  {
1957  pbody = mutt_body_new();
1958  pbody->next = e_templ->content; /* don't kill command-line attachments */
1959  e_templ->content = pbody;
1960 
1961  ctype = mutt_str_strdup(C_ContentType);
1962  if (!ctype)
1963  ctype = mutt_str_strdup("text/plain");
1964  mutt_parse_content_type(ctype, e_templ->content);
1965  FREE(&ctype);
1966  e_templ->content->unlink = true;
1967  e_templ->content->use_disp = false;
1968  e_templ->content->disposition = DISP_INLINE;
1969 
1970  if (!tempfile)
1971  {
1972  mutt_mktemp(buf, sizeof(buf));
1973  fp_tmp = mutt_file_fopen(buf, "w+");
1974  e_templ->content->filename = mutt_str_strdup(buf);
1975  }
1976  else
1977  {
1978  fp_tmp = mutt_file_fopen(tempfile, "a+");
1979  e_templ->content->filename = mutt_str_strdup(tempfile);
1980  }
1981  }
1982  else
1983  fp_tmp = mutt_file_fopen(e_templ->content->filename, "a+");
1984 
1985  if (!fp_tmp)
1986  {
1987  mutt_debug(LL_DEBUG1, "can't create tempfile %s (errno=%d)\n",
1988  e_templ->content->filename, errno);
1989  mutt_perror(e_templ->content->filename);
1990  goto cleanup;
1991  }
1992  }
1993 
1994  /* this is handled here so that the user can match ~f in send-hook */
1995  if (e_cur && C_ReverseName && !(flags & (SEND_POSTPONED | SEND_RESEND)))
1996  {
1997  /* We shouldn't have to worry about alias expansion here since we are
1998  * either replying to a real or postponed message, therefore no aliases
1999  * should exist since the user has not had the opportunity to add
2000  * addresses to the list. We just have to ensure the postponed messages
2001  * have their aliases expanded. */
2002 
2003  if (!TAILQ_EMPTY(&e_templ->env->from))
2004  {
2005  mutt_debug(LL_DEBUG5, "e_templ->env->from before set_reverse_name: %s\n",
2006  TAILQ_FIRST(&e_templ->env->from)->mailbox);
2007  mutt_addrlist_clear(&e_templ->env->from);
2008  }
2009  set_reverse_name(&e_templ->env->from, e_cur->env);
2010  }
2011  if (e_cur && C_ReplyWithXorig && !(flags & (SEND_POSTPONED | SEND_RESEND | SEND_FORWARD)))
2012  {
2013  /* We shouldn't have to worry about freeing 'e_templ->env->from' before
2014  * setting it here since this code will only execute when doing some
2015  * sort of reply. The pointer will only be set when using the -H command
2016  * line option.
2017  *
2018  * If there is already a from address recorded in 'e_templ->env->from',
2019  * then it theoretically comes from C_ReverseName handling, and we don't use
2020  * the 'X-Orig-To header'. */
2021  if (!TAILQ_EMPTY(&e_cur->env->x_original_to) && TAILQ_EMPTY(&e_templ->env->from))
2022  {
2023  mutt_addrlist_copy(&e_templ->env->from, &e_cur->env->x_original_to, false);
2024  mutt_debug(LL_DEBUG5, "e_templ->env->from extracted from X-Original-To: header: %s\n",
2025  TAILQ_FIRST(&e_templ->env->from)->mailbox);
2026  }
2027  }
2028 
2029  if (!(flags & (SEND_POSTPONED | SEND_RESEND)) &&
2030  !((flags & SEND_DRAFT_FILE) && C_ResumeDraftFiles))
2031  {
2032  if ((flags & (SEND_REPLY | SEND_FORWARD | SEND_TO_SENDER)) && ctx &&
2033  (envelope_defaults(e_templ->env, ctx->mailbox, el, flags) == -1))
2034  {
2035  goto cleanup;
2036  }
2037 
2038  if (C_Hdrs)
2039  process_user_recips(e_templ->env);
2040 
2041  /* Expand aliases and remove duplicates/crossrefs */
2042  mutt_expand_aliases_env(e_templ->env);
2043 
2044  if (flags & SEND_REPLY)
2045  mutt_fix_reply_recipients(e_templ->env);
2046 
2047 #ifdef USE_NNTP
2048  if ((flags & SEND_NEWS) && ctx && (ctx->mailbox->magic == MUTT_NNTP) &&
2049  !e_templ->env->newsgroups)
2050  {
2051  e_templ->env->newsgroups =
2052  mutt_str_strdup(((struct NntpMboxData *) ctx->mailbox->mdata)->group);
2053  }
2054 #endif
2055 
2056  if (!(flags & (SEND_MAILX | SEND_BATCH)) &&
2057  !(C_Autoedit && C_EditHeaders) && !((flags & SEND_REPLY) && C_FastReply))
2058  {
2059  if (edit_envelope(e_templ->env, flags) == -1)
2060  goto cleanup;
2061  }
2062 
2063  /* the from address must be set here regardless of whether or not
2064  * $use_from is set so that the '~P' (from you) operator in send-hook
2065  * patterns will work. if $use_from is unset, the from address is killed
2066  * after send-hooks are evaluated */
2067 
2068  const bool killfrom = TAILQ_EMPTY(&e_templ->env->from);
2069  if (killfrom)
2070  {
2072  }
2073 
2074  if ((flags & SEND_REPLY) && e_cur)
2075  {
2076  /* change setting based upon message we are replying to */
2077  mutt_message_hook(ctx ? ctx->mailbox : NULL, e_cur, MUTT_REPLY_HOOK);
2078 
2079  /* set the replied flag for the message we are generating so that the
2080  * user can use ~Q in a send-hook to know when reply-hook's are also
2081  * being used. */
2082  e_templ->replied = true;
2083  }
2084 
2085  /* change settings based upon recipients */
2086 
2087  mutt_message_hook(NULL, e_templ, MUTT_SEND_HOOK);
2088 
2089  /* Unset the replied flag from the message we are composing since it is
2090  * no longer required. This is done here because the FCC'd copy of
2091  * this message was erroneously get the 'R'eplied flag when stored in
2092  * a maildir-style mailbox. */
2093  e_templ->replied = false;
2094 
2095  if (!(flags & SEND_KEY))
2096  {
2097  if (C_TextFlowed && (e_templ->content->type == TYPE_TEXT) &&
2098  (mutt_str_strcasecmp(e_templ->content->subtype, "plain") == 0))
2099  {
2100  mutt_param_set(&e_templ->content->parameter, "format", "flowed");
2101  }
2102  }
2103 
2104  /* $use_from and/or $from might have changed in a send-hook */
2105  if (killfrom)
2106  {
2107  mutt_addrlist_clear(&e_templ->env->from);
2108  if (C_UseFrom && !(flags & (SEND_POSTPONED | SEND_RESEND)))
2110  }
2111 
2112  if (C_Hdrs)
2113  process_user_header(e_templ->env);
2114 
2115  if (flags & SEND_BATCH)
2116  mutt_file_copy_stream(stdin, fp_tmp);
2117 
2118  if (C_SigOnTop && !(flags & (SEND_MAILX | SEND_KEY | SEND_BATCH)) &&
2119  C_Editor && (mutt_str_strcmp(C_Editor, "builtin") != 0))
2120  {
2121  append_signature(fp_tmp);
2122  }
2123 
2124  /* include replies/forwarded messages, unless we are given a template */
2125  if (!tempfile && (ctx || !(flags & (SEND_REPLY | SEND_FORWARD))) &&
2126  (generate_body(fp_tmp, e_templ, flags, ctx ? ctx->mailbox : NULL, el) == -1))
2127  {
2128  goto cleanup;
2129  }
2130 
2131  if (!C_SigOnTop && !(flags & (SEND_MAILX | SEND_KEY | SEND_BATCH)) &&
2132  C_Editor && (mutt_str_strcmp(C_Editor, "builtin") != 0))
2133  {
2134  append_signature(fp_tmp);
2135  }
2136  }
2137 
2138  /* This hook is even called for postponed messages, and can, e.g., be
2139  * used for setting the editor, the sendmail path, or the
2140  * envelope sender. */
2141  mutt_message_hook(NULL, e_templ, MUTT_SEND2_HOOK);
2142 
2143  /* wait until now to set the real name portion of our return address so
2144  * that $realname can be set in a send-hook */
2145  {
2146  struct Address *from = TAILQ_FIRST(&e_templ->env->from);
2147  if (from && !from->personal && !(flags & (SEND_RESEND | SEND_POSTPONED)))
2149  }
2150 
2151  if (!(((WithCrypto & APPLICATION_PGP) != 0) && (flags & SEND_KEY)))
2152  mutt_file_fclose(&fp_tmp);
2153 
2154  if (flags & SEND_MAILX)
2155  {
2156  if (mutt_builtin_editor(e_templ->content->filename, e_templ, e_cur) == -1)
2157  goto cleanup;
2158  }
2159  else if (!(flags & SEND_BATCH))
2160  {
2161  struct stat st;
2162  time_t mtime = mutt_file_decrease_mtime(e_templ->content->filename, NULL);
2163 
2164  mutt_update_encoding(e_templ->content);
2165 
2166  /* Select whether or not the user's editor should be called now. We
2167  * don't want to do this when:
2168  * 1) we are sending a key/cert
2169  * 2) we are forwarding a message and the user doesn't want to edit it.
2170  * This is controlled by the quadoption $forward_edit. However, if
2171  * both $edit_headers and $autoedit are set, we want to ignore the
2172  * setting of $forward_edit because the user probably needs to add the
2173  * recipients. */
2174  if (!(flags & SEND_KEY) &&
2175  (((flags & SEND_FORWARD) == 0) || (C_EditHeaders && C_Autoedit) ||
2176  (query_quadoption(C_ForwardEdit, _("Edit forwarded message?")) == MUTT_YES)))
2177  {
2178  /* If the this isn't a text message, look for a mailcap edit command */
2179  if (mutt_needs_mailcap(e_templ->content))
2180  {
2181  if (!mutt_edit_attachment(e_templ->content))
2182  goto cleanup;
2183  }
2184  else if (!C_Editor || (mutt_str_strcmp("builtin", C_Editor) == 0))
2185  mutt_builtin_editor(e_templ->content->filename, e_templ, e_cur);
2186  else if (C_EditHeaders)
2187  {
2188  mutt_env_to_local(e_templ->env);
2189  mutt_edit_headers(C_Editor, e_templ->content->filename, e_templ, fcc, sizeof(fcc));
2190  mutt_env_to_intl(e_templ->env, NULL, NULL);
2191  }
2192  else
2193  {
2195  if (stat(e_templ->content->filename, &st) == 0)
2196  {
2197  if (mtime != st.st_mtime)
2198  fix_end_of_file(e_templ->content->filename);
2199  }
2200  else
2201  mutt_perror(e_templ->content->filename);
2202  }
2203 
2204  /* If using format=flowed, perform space stuffing. Avoid stuffing when
2205  * recalling a postponed message where the stuffing was already
2206  * performed. If it has already been performed, the format=flowed
2207  * parameter will be present. */
2208  if (C_TextFlowed && (e_templ->content->type == TYPE_TEXT) &&
2209  (mutt_str_strcasecmp("plain", e_templ->content->subtype) == 0))
2210  {
2211  char *p = mutt_param_get(&e_templ->content->parameter, "format");
2212  if (mutt_str_strcasecmp("flowed", p) != 0)
2213  rfc3676_space_stuff(e_templ);
2214  }
2215 
2216  mutt_message_hook(NULL, e_templ, MUTT_SEND2_HOOK);
2217  }
2218 
2219  if (!(flags & (SEND_POSTPONED | SEND_FORWARD | SEND_KEY | SEND_RESEND | SEND_DRAFT_FILE)))
2220  {
2221  if (stat(e_templ->content->filename, &st) == 0)
2222  {
2223  /* if the file was not modified, bail out now */
2224  if ((mtime == st.st_mtime) && !e_templ->content->next &&
2226  _("Abort unmodified message?")) == MUTT_YES))
2227  {
2228  mutt_message(_("Aborted unmodified message"));
2229  goto cleanup;
2230  }
2231  }
2232  else
2233  mutt_perror(e_templ->content->filename);
2234  }
2235  }
2236 
2237  /* Set the message security unless:
2238  * 1) crypto support is not enabled (WithCrypto==0)
2239  * 2) pgp: header field was present during message editing with $edit_headers (e_templ->security != 0)
2240  * 3) we are resending a message
2241  * 4) we are recalling a postponed message (don't override the user's saved settings)
2242  * 5) we are in mailx mode
2243  * 6) we are in batch mode
2244  *
2245  * This is done after allowing the user to edit the message so that security
2246  * settings can be configured with send2-hook and $edit_headers. */
2247  if ((WithCrypto != 0) && (e_templ->security == 0) &&
2248  !(flags & (SEND_BATCH | SEND_MAILX | SEND_POSTPONED | SEND_RESEND)))
2249  {
2250  if (
2251 #ifdef USE_AUTOCRYPT
2253 #else
2254  0
2255 #endif
2256  && e_cur && (e_cur->security & SEC_AUTOCRYPT))
2257  {
2259  }
2260  else
2261  {
2262  if (C_CryptAutosign)
2263  e_templ->security |= SEC_SIGN;
2264  if (C_CryptAutoencrypt)
2265  e_templ->security |= SEC_ENCRYPT;
2266  if (C_CryptReplyencrypt && e_cur && (e_cur->security & SEC_ENCRYPT))
2267  e_templ->security |= SEC_ENCRYPT;
2268  if (C_CryptReplysign && e_cur && (e_cur->security & SEC_SIGN))
2269  e_templ->security |= SEC_SIGN;
2270  if (C_CryptReplysignencrypted && e_cur && (e_cur->security & SEC_ENCRYPT))
2271  e_templ->security |= SEC_SIGN;
2272  if (((WithCrypto & APPLICATION_PGP) != 0) &&
2274  {
2275  if (C_PgpAutoinline)
2276  e_templ->security |= SEC_INLINE;
2277  if (C_PgpReplyinline && e_cur && (e_cur->security & SEC_INLINE))
2278  e_templ->security |= SEC_INLINE;
2279  }
2280  }
2281 
2282  if (e_templ->security || C_CryptOpportunisticEncrypt)
2283  {
2284  /* When replying / forwarding, use the original message's
2285  * crypto system. According to the documentation,
2286  * smime_is_default should be disregarded here.
2287  *
2288  * Problem: At least with forwarding, this doesn't really
2289  * make much sense. Should we have an option to completely
2290  * disable individual mechanisms at run-time? */
2291  if (e_cur)
2292  {
2293  if (((WithCrypto & APPLICATION_PGP) != 0) && C_CryptAutopgp &&
2294  (e_cur->security & APPLICATION_PGP))
2295  {
2296  e_templ->security |= APPLICATION_PGP;
2297  }
2298  else if (((WithCrypto & APPLICATION_SMIME) != 0) && C_CryptAutosmime &&
2299  (e_cur->security & APPLICATION_SMIME))
2300  {
2301  e_templ->security |= APPLICATION_SMIME;
2302  }
2303  }
2304 
2305  /* No crypto mechanism selected? Use availability + smime_is_default
2306  * for the decision. */
2307  if (!(e_templ->security & (APPLICATION_SMIME | APPLICATION_PGP)))
2308  {
2309  if (((WithCrypto & APPLICATION_SMIME) != 0) && C_CryptAutosmime && C_SmimeIsDefault)
2310  {
2311  e_templ->security |= APPLICATION_SMIME;
2312  }
2313  else if (((WithCrypto & APPLICATION_PGP) != 0) && C_CryptAutopgp)
2314  {
2315  e_templ->security |= APPLICATION_PGP;
2316  }
2317  else if (((WithCrypto & APPLICATION_SMIME) != 0) && C_CryptAutosmime)
2318  {
2319  e_templ->security |= APPLICATION_SMIME;
2320  }
2321  }
2322  }
2323 
2324  /* opportunistic encrypt relies on SMIME or PGP already being selected */
2326  {
2327  /* If something has already enabled encryption, e.g. C_CryptAutoencrypt
2328  * or C_CryptReplyencrypt, then don't enable opportunistic encrypt for
2329  * the message. */
2330  if (!(e_templ->security & (SEC_ENCRYPT | SEC_AUTOCRYPT)))
2331  {
2332  e_templ->security |= SEC_OPPENCRYPT;
2333  crypt_opportunistic_encrypt(e_templ);
2334  }
2335  }
2336 
2337  /* No permissible mechanisms found. Don't sign or encrypt. */
2338  if (!(e_templ->security & (APPLICATION_SMIME | APPLICATION_PGP)))
2339  e_templ->security = SEC_NO_FLAGS;
2340  }
2341 
2342  /* Deal with the corner case where the crypto module backend is not available.
2343  * This can happen if configured without pgp/smime and with gpgme, but
2344  * $crypt_use_gpgme is unset. */
2345  if (e_templ->security && !crypt_has_module_backend(e_templ->security))
2346  {
2347  mutt_error(_(
2348  "No crypto backend configured. Disabling message security setting."));
2349  e_templ->security = SEC_NO_FLAGS;
2350  }
2351 
2352  /* specify a default fcc. if we are in batchmode, only save a copy of
2353  * the message if the value of $copy is yes or ask-yes */
2354 
2355  if (!fcc[0] && !(flags & SEND_POSTPONED_FCC) && (!(flags & SEND_BATCH) || (C_Copy & 0x1)))
2356  {
2357  /* set the default FCC */
2358  const bool killfrom = TAILQ_EMPTY(&e_templ->env->from);
2359  if (killfrom)
2360  {
2362  }
2363  mutt_select_fcc(fcc, sizeof(fcc), e_templ);
2364  if (killfrom)
2365  {
2366  mutt_addrlist_clear(&e_templ->env->from);
2367  }
2368  }
2369 
2370  mutt_update_encoding(e_templ->content);
2371 
2372  if (!(flags & (SEND_MAILX | SEND_BATCH)))
2373  {
2374  main_loop:
2375 
2376  mutt_pretty_mailbox(fcc, sizeof(fcc));
2377  i = mutt_compose_menu(e_templ, fcc, sizeof(fcc), e_cur,
2379  if (i == -1)
2380  {
2381 /* abort */
2382 #ifdef USE_NNTP
2383  if (flags & SEND_NEWS)
2384  mutt_message(_("Article not posted"));
2385  else
2386 #endif
2387  mutt_message(_("Mail not sent"));
2388  goto cleanup;
2389  }
2390  else if (i == 1)
2391  {
2392  if (postpone_message(e_templ, e_cur, fcc, flags) != 0)
2393  goto main_loop;
2394  mutt_message(_("Message postponed"));
2395  rc = 1;
2396  goto cleanup;
2397  }
2398  }
2399 
2400 #ifdef USE_NNTP
2401  if (!(flags & SEND_NEWS))
2402 #endif
2403  if ((mutt_addrlist_count_recips(&e_templ->env->to) == 0) &&
2404  (mutt_addrlist_count_recips(&e_templ->env->cc) == 0) &&
2405  (mutt_addrlist_count_recips(&e_templ->env->bcc) == 0))
2406  {
2407  if (!(flags & SEND_BATCH))
2408  {
2409  mutt_error(_("No recipients specified"));
2410  goto main_loop;
2411  }
2412  else
2413  {
2414  puts(_("No recipients specified"));
2415  goto cleanup;
2416  }
2417  }
2418 
2419  if (mutt_env_to_intl(e_templ->env, &tag, &err))
2420  {
2421  mutt_error(_("Bad IDN in '%s': '%s'"), tag, err);
2422  FREE(&err);
2423  if (!(flags & SEND_BATCH))
2424  goto main_loop;
2425  else
2426  goto cleanup;
2427  }
2428 
2429  if (!e_templ->env->subject && !(flags & SEND_BATCH) &&
2430  (query_quadoption(C_AbortNosubject, _("No subject, abort sending?")) != MUTT_NO))
2431  {
2432  /* if the abort is automatic, print an error message */
2433  if (C_AbortNosubject == MUTT_YES)
2434  mutt_error(_("No subject specified"));
2435  goto main_loop;
2436  }
2437 #ifdef USE_NNTP
2438  if ((flags & SEND_NEWS) && !e_templ->env->subject)
2439  {
2440  mutt_error(_("No subject specified"));
2441  goto main_loop;
2442  }
2443 
2444  if ((flags & SEND_NEWS) && !e_templ->env->newsgroups)
2445  {
2446  mutt_error(_("No newsgroup specified"));
2447  goto main_loop;
2448  }
2449 #endif
2450 
2451  if (!(flags & SEND_BATCH) && (C_AbortNoattach != MUTT_NO) &&
2452  !e_templ->content->next && (e_templ->content->type == TYPE_TEXT) &&
2453  (mutt_str_strcasecmp(e_templ->content->subtype, "plain") == 0) &&
2454  search_attach_keyword(e_templ->content->filename) &&
2456  _("No attachments, cancel sending?")) != MUTT_NO))
2457  {
2458  /* if the abort is automatic, print an error message */
2459  if (C_AbortNoattach == MUTT_YES)
2460  {
2461  mutt_error(_("Message contains text matching "
2462  "\"$abort_noattach_regex\". Not sending."));
2463  }
2464  goto main_loop;
2465  }
2466 
2467  if (e_templ->content->next)
2468  e_templ->content = mutt_make_multipart(e_templ->content);
2469 
2470  /* Ok, we need to do it this way instead of handling all fcc stuff in
2471  * one place in order to avoid going to main_loop with encoded "env"
2472  * in case of error. Ugh. */
2473 
2474  mutt_encode_descriptions(e_templ->content, true);
2475 
2476  /* Make sure that clear_content and free_clear_content are
2477  * properly initialized -- we may visit this particular place in
2478  * the code multiple times, including after a failed call to
2479  * mutt_protect(). */
2480 
2481  clear_content = NULL;
2482  free_clear_content = false;
2483 
2484  if (WithCrypto)
2485  {
2486  if (e_templ->security & (SEC_ENCRYPT | SEC_SIGN | SEC_AUTOCRYPT))
2487  {
2488  /* save the decrypted attachments */
2489  clear_content = e_templ->content;
2490 
2491  if ((crypt_get_keys(e_templ, &pgpkeylist, 0) == -1) ||
2492  (mutt_protect(e_templ, pgpkeylist, false) == -1))
2493  {
2494  e_templ->content = mutt_remove_multipart(e_templ->content);
2495 
2496  FREE(&pgpkeylist);
2497 
2498  decode_descriptions(e_templ->content);
2499  goto main_loop;
2500  }
2501  mutt_encode_descriptions(e_templ->content, false);
2502  }
2503 
2504  /* at this point, e_templ->content is one of the following three things:
2505  * - multipart/signed. In this case, clear_content is a child
2506  * - multipart/encrypted. In this case, clear_content exists independently
2507  * - application/pgp. In this case, clear_content exists independently
2508  * - something else. In this case, it's the same as clear_content
2509  */
2510 
2511  /* This is ugly -- lack of "reporting back" from mutt_protect(). */
2512 
2513  if (clear_content && (e_templ->content != clear_content) &&
2514  (e_templ->content->parts != clear_content))
2515  free_clear_content = true;
2516  }
2517 
2518  if (!OptNoCurses && !(flags & SEND_MAILX))
2519  mutt_message(_("Sending message..."));
2520 
2521  mutt_prepare_envelope(e_templ->env, true);
2522 
2523  if (C_FccBeforeSend)
2524  save_fcc(e_templ, fcc, sizeof(fcc), clear_content, pgpkeylist, flags, &finalpath);
2525 
2526  i = send_message(e_templ);
2527  if (i < 0)
2528  {
2529  if (!(flags & SEND_BATCH))
2530  {
2531  if (!WithCrypto)
2532  ;
2533  else if ((e_templ->security & (SEC_ENCRYPT | SEC_AUTOCRYPT)) ||
2534  ((e_templ->security & SEC_SIGN) && (e_templ->content->type == TYPE_APPLICATION)))
2535  {
2536  if (e_templ->content != clear_content)
2537  {
2538  mutt_body_free(&e_templ->content); /* destroy PGP data */
2539  e_templ->content = clear_content; /* restore clear text. */
2540  }
2541  }
2542  else if ((e_templ->security & SEC_SIGN) && (e_templ->content->type == TYPE_MULTIPART))
2543  {
2544  mutt_body_free(&e_templ->content->parts->next); /* destroy sig */
2545  e_templ->content = mutt_remove_multipart(e_templ->content);
2546  }
2547 
2548  FREE(&pgpkeylist);
2549  mutt_env_free(&e_templ->content->mime_headers); /* protected headers */
2550  e_templ->content = mutt_remove_multipart(e_templ->content);
2551  decode_descriptions(e_templ->content);
2552  mutt_unprepare_envelope(e_templ->env);
2553  FREE(&finalpath);
2554  goto main_loop;
2555  }
2556  else
2557  {
2558  puts(_("Could not send the message"));
2559  goto cleanup;
2560  }
2561  }
2562 
2563  if (!C_FccBeforeSend)
2564  save_fcc(e_templ, fcc, sizeof(fcc), clear_content, pgpkeylist, flags, &finalpath);
2565 
2566  if (!OptNoCurses && !(flags & SEND_MAILX))
2567  {
2568  mutt_message((i != 0) ? _("Sending in background") :
2569  (flags & SEND_NEWS) ? _("Article posted") : /* USE_NNTP */
2570  _("Mail sent"));
2571 #ifdef USE_NOTMUCH
2572  if (C_NmRecord)
2573  nm_record_message(ctx ? ctx->mailbox : NULL, finalpath, e_cur);
2574 #endif
2575  mutt_sleep(0);
2576  }
2577 
2578  if (WithCrypto)
2579  FREE(&pgpkeylist);
2580 
2581  if ((WithCrypto != 0) && free_clear_content)
2582  mutt_body_free(&clear_content);
2583 
2584  /* set 'replied' flag only if the user didn't change/remove
2585  * In-Reply-To: and References: headers during edit */
2586  if (flags & SEND_REPLY)
2587  {
2588  if (!(flags & SEND_POSTPONED) && ctx && ctx->mailbox)
2589  {
2590  STAILQ_FOREACH(en, el, entries)
2591  {
2592  mutt_set_flag(ctx->mailbox, en->email, MUTT_REPLIED, is_reply(en->email, e_templ));
2593  }
2594  }
2595  }
2596 
2597  rc = 0;
2598 
2599 cleanup:
2600 
2601  if (flags & SEND_POSTPONED)
2602  {
2603  if (WithCrypto & APPLICATION_PGP)
2604  {
2605  FREE(&C_PgpSignAs);
2606  C_PgpSignAs = pgp_signas;
2607  }
2608  if (WithCrypto & APPLICATION_SMIME)
2609  {
2610  FREE(&C_SmimeSignAs);
2611  C_SmimeSignAs = smime_signas;
2612  }
2613  }
2614 
2615  mutt_file_fclose(&fp_tmp);
2616  if (!(flags & SEND_NO_FREE_HEADER))
2617  email_free(&e_templ);
2618 
2619  FREE(&finalpath);
2620  return rc;
2621 }
#define MUTT_SEND_HOOK
send-hook: when composing a new email
Definition: hook.h:47
void mutt_fix_reply_recipients(struct Envelope *env)
Remove duplicate recipients.
Definition: send.c:885
bool C_Hdrs
Config: Add custom headers to outgoing mail.
Definition: send.c:117
char * filename
when sending a message, this is the file to which this structure refers
Definition: body.h:46
#define SEC_AUTOCRYPT
Message will be, or was Autocrypt encrypt+signed.
Definition: ncrypt.h:131
WHERE bool C_Autocrypt
Config: Enables the Autocrypt feature.
Definition: globals.h:205
struct Envelope * mime_headers
Memory hole protected headers.
Definition: body.h:63
struct Body * mutt_remove_multipart(struct Body *b)
Extract the multipart body if it exists.
Definition: sendlib.c:1742
#define mutt_set_flag(m, e, flag, bf)
Definition: protos.h:69
#define SEND_POSTPONED_FCC
Used by mutt_get_postponed() to signal that the x-mutt-fcc header field was present.
Definition: send.h:96
#define SEND_TO_SENDER
Compose new email to sender.
Definition: send.h:99
The envelope/body of an email.
Definition: email.h:39
#define TAILQ_FIRST(head)
Definition: queue.h:717
#define mutt_perror(...)
Definition: logging.h:85
static void fix_end_of_file(const char *data)
Ensure a file ends with a linefeed.
Definition: send.c:1444
WHERE bool C_AutocryptReply
Config: Replying to an autocrypt email automatically enables autocrypt in the reply.
Definition: globals.h:206
&#39;NNTP&#39; (Usenet) Mailbox type
Definition: mailbox.h:51
unsigned char C_AbortNoattach
Config: Abort sending the email if attachments are missing.
Definition: send.c:92
static bool search_attach_keyword(char *filename)
Search an email for &#39;attachment&#39; keywords.
Definition: send.c:1531
User aborted the question (with Ctrl-G)
Definition: quad.h:37
enum QuadOption query_quadoption(enum QuadOption opt, const char *prompt)
Ask the user a quad-question.
Definition: init.c:3331
#define mutt_message(...)
Definition: logging.h:83
int mutt_parse_mailto(struct Envelope *e, char **body, const char *src)
Parse a mailto:// url.
Definition: parse.c:1587
User answered &#39;Yes&#39;, or assume &#39;Yes&#39;.
Definition: quad.h:39
struct AddressList bcc
Email&#39;s &#39;Bcc&#39; list.
Definition: envelope.h:60
void mutt_addrlist_clear(struct AddressList *al)
Unlink and free all Address in an AddressList.
Definition: address.c:1381
#define SEND_DRAFT_FILE
Used by the -H flag.
Definition: send.h:98
#define SEC_AUTOCRYPT_OVERRIDE
Indicates manual set/unset of encryption.
Definition: ncrypt.h:132
void mutt_expand_aliases_env(struct Envelope *env)
Expand aliases in all the fields of an Envelope.
Definition: alias.c:318
static int envelope_defaults(struct Envelope *env, struct Mailbox *m, struct EmailList *el, SendFlags flags)
Fill in some defaults for a new email.
Definition: send.c:1005
#define SEC_NO_FLAGS
No flags are set.
Definition: ncrypt.h:121
static void process_user_header(struct Envelope *env)
Process the user headers.
Definition: send.c:381
#define SEND_FORWARD
Forward email.
Definition: send.h:90
void mutt_addrlist_copy(struct AddressList *dst, const struct AddressList *src, bool prune)
Copy a list of addresses into another list.
Definition: address.c:727
bool C_FccBeforeSend
Config: Save FCCs before sending the message.
Definition: send.c:109
struct Body * content
List of MIME parts.
Definition: email.h:92
int mutt_edit_attachment(struct Body *a)
Edit an attachment.
Definition: mutt_attach.c:254
static int save_fcc(struct Email *e, char *fcc, size_t fcc_len, struct Body *clear_content, char *pgpkeylist, SendFlags flags, char **finalpath)
Save an Email to a &#39;sent mail&#39; folder.
Definition: send.c:1573
#define _(a)
Definition: message.h:28
unsigned char C_AbortUnmodified
Config: Abort the sending if the message hasn&#39;t been edited.
Definition: send.c:95
WHERE bool C_PgpAutoinline
Config: Use old-style inline PGP messages (not recommended)
Definition: globals.h:288
struct Body * next
next attachment in the list
Definition: body.h:53
An email address.
Definition: address.h:34
WHERE unsigned char C_Copy
Config: Save outgoing emails to $record.
Definition: globals.h:186
WHERE bool OptNoCurses
(pseudo) when sending in batch mode
Definition: options.h:46
#define SEC_INLINE
Email has an inline signature.
Definition: ncrypt.h:129
bool C_CryptAutosign
Config: Automatically PGP sign all outgoing mail.
Definition: send.c:101
int crypt_get_keys(struct Email *e, char **keylist, bool oppenc_mode)
Check we have all the keys we need.
Definition: crypt.c:952
int mutt_env_to_intl(struct Envelope *env, const char **tag, char **err)
Convert an Envelope&#39;s Address fields to Punycode format.
Definition: envelope.c:312
#define SEC_ENCRYPT
Email is encrypted.
Definition: ncrypt.h:122
#define SEND_POSTPONED
Recall a postponed email.
Definition: send.h:91
bool C_CryptReplysign
Config: Sign replies to signed messages.
Definition: send.c:104
void mutt_select_fcc(char *path, size_t pathlen, struct Email *e)
Select the FCC path for an email.
Definition: hook.c:700
Messages that have been replied to.
Definition: mutt.h:101
The body of an email.
Definition: body.h:34
void mutt_prepare_envelope(struct Envelope *env, bool final)
Prepare an email header.
Definition: sendlib.c:2997
unsigned int disposition
content-disposition
Definition: body.h:67
int nm_record_message(struct Mailbox *m, char *path, struct Email *e)
Add a message to the Notmuch database.
WHERE bool C_SmimeIsDefault
Config: Use SMIME rather than PGP by default.
Definition: globals.h:284
bool C_CryptAutosmime
Config: Allow automatic SMIME functions.
Definition: send.c:102
#define SEND_MAILX
Send email in Mailx compatibility mode.
Definition: send.h:93
void mutt_sleep(short s)
Sleep for a while.
Definition: muttlib.c:1509
WHERE bool C_EditHeaders
Config: Let the user edit the email headers whilst editing an email.
Definition: globals.h:217
struct Mailbox * mailbox
Definition: context.h:50
unsigned char C_Recall
Config: Recall postponed mesaages when asked to compose a message.
Definition: send.c:127
struct Body * mutt_body_new(void)
Create a new Body.
Definition: body.c:43
unsigned char C_AbortNosubject
Config: Abort creating the email if subject is missing.
Definition: send.c:94
struct AddressList from
Email&#39;s &#39;From&#39; list.
Definition: envelope.h:57
enum MailboxType magic
Mailbox type.
Definition: mailbox.h:116
void mutt_update_encoding(struct Body *a)
Update the encoding type.
Definition: sendlib.c:1455
static void process_user_recips(struct Envelope *env)
Process the user headers.
Definition: send.c:354
int mutt_file_fclose(FILE **fp)
Close a FILE handle (and NULL the pointer)
Definition: file.c:150
struct Envelope * env
Envelope information.
Definition: email.h:91
static void decode_descriptions(struct Body *b)
rfc2047 decode them in case of an error
Definition: send.c:1427
struct AddressList cc
Email&#39;s &#39;Cc&#39; list.
Definition: envelope.h:59
WHERE bool C_Autoedit
Config: Skip the initial compose menu and edit the email.
Definition: globals.h:208
#define SEND_LIST_REPLY
Reply to mailing list.
Definition: send.h:89
static bool is_reply(struct Email *reply, struct Email *orig)
Is one email a reply to another?
Definition: send.c:1513
void * mdata
Driver specific data.
Definition: mailbox.h:147
struct Envelope * mutt_env_new(void)
Create a new Envelope.
Definition: envelope.c:42
struct Body * mutt_make_multipart(struct Body *b)
Create a multipart email.
Definition: sendlib.c:1716
#define SEND_KEY
Mail a PGP public key.
Definition: send.h:94
char * subtype
content-type subtype
Definition: body.h:37
bool C_FastReply
Config: Don&#39;t prompt for the recipients and subject when replying/forwarding.
Definition: send.c:107
#define SEND_RESEND
Reply using the current email as a template.
Definition: send.h:95
void mutt_unprepare_envelope(struct Envelope *env)
Undo the encodings of mutt_prepare_envelope()
Definition: sendlib.c:3036
#define mutt_mktemp(buf, buflen)
Definition: muttlib.h:76
#define SEC_SIGN
Email is signed.
Definition: ncrypt.h:123
struct Address * mutt_default_from(void)
Get a default &#39;from&#39; Address.
Definition: send.c:1307
WHERE bool C_CryptOpportunisticEncrypt
Config: Enable encryption when the recipient&#39;s key is available.
Definition: globals.h:280
bool C_ReverseName
Config: Set the &#39;From&#39; from the address the email was sent to.
Definition: send.c:131
int mutt_compose_menu(struct Email *e, char *fcc, size_t fcclen, struct Email *e_cur, int flags)
Allow the user to edit the message envelope.
Definition: compose.c:1049
#define PATH_MAX
Definition: mutt.h:52
User answered &#39;No&#39;, or assume &#39;No&#39;.
Definition: quad.h:38
void mutt_encode_descriptions(struct Body *b, bool recurse)
rfc2047 encode the content-descriptions
Definition: send.c:1410
Type: &#39;text/*&#39;.
Definition: mime.h:38
static int generate_body(FILE *fp_tmp, struct Email *e, SendFlags flags, struct Mailbox *m, struct EmailList *el)
Create a new email body.
Definition: send.c:1075
void mutt_env_free(struct Envelope **ptr)
Free an Envelope.
Definition: envelope.c:96
int mutt_protect(struct Email *e, char *keylist, bool postpone)
Encrypt and/or sign a message.
Definition: crypt.c:172
struct Body * parts
parts of a multipart or message/rfc822
Definition: body.h:54
#define SEND_NEWS
Reply to a news article.
Definition: send.h:101
void mutt_pretty_mailbox(char *buf, size_t buflen)
Shorten a mailbox path using &#39;~&#39; or &#39;=&#39;.
Definition: muttlib.c:612
#define STAILQ_FOREACH(var, head, field)
Definition: queue.h:350
static void set_reverse_name(struct AddressList *al, struct Envelope *env)
Try to set the &#39;from&#39; field from the recipients.
Definition: send.c:1258
#define STAILQ_NEXT(elm, field)
Definition: queue.h:398
SecurityFlags security
bit 0-10: flags, bit 11,12: application, bit 13: traditional pgp See: ncrypt/ncrypt.h pgplib.h, smime.h
Definition: email.h:41
bool C_PgpReplyinline
Config: Reply using old-style inline PGP messages (not recommended)
Definition: send.c:123
#define SEND_REPLY
Reply to sender.
Definition: send.h:87
NNTP-specific Mailbox data -.
Definition: nntp.h:138
bool C_SigOnTop
Config: Insert the signature before the quoted text.
Definition: send.c:135
#define SEND_NO_FREE_HEADER
Used by the -E flag.
Definition: send.h:97
void rfc3676_space_stuff(struct Email *e)
Perform required RFC3676 space stuffing.
Definition: rfc3676.c:398
unsigned char C_ForwardEdit
Config: Automatically start the editor when forwarding a message.
Definition: send.c:114
unsigned int type
content-type primary type
Definition: body.h:65
#define SEC_OPPENCRYPT
Opportunistic encrypt mode.
Definition: ncrypt.h:130
char * list_post
This stores a mailto URL, or nothing.
Definition: envelope.h:65
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: ncrypt.h:134
bool C_CryptReplyencrypt
Config: Encrypt replies to encrypted messages.
Definition: send.c:103
int mutt_addrlist_count_recips(const struct AddressList *al)
Count the number of Addresses with valid recipients.
Definition: address.c:834
bool crypt_has_module_backend(SecurityFlags type)
Is there a crypto backend for a given type?
Definition: cryptglue.c:159
char * personal
Real name of address.
Definition: address.h:36
int mutt_num_postponed(struct Mailbox *m, bool force)
Return the number of postponed messages.
Definition: postpone.c:85
WHERE bool C_TextFlowed
Config: Generate &#39;format=flowed&#39; messages.
Definition: globals.h:268
void mutt_parse_content_type(const char *s, struct Body *ct)
Parse a content type.
Definition: parse.c:455
void mutt_env_to_local(struct Envelope *env)
Convert an Envelope&#39;s Address fields to local format.
Definition: envelope.c:274
void crypt_opportunistic_encrypt(struct Email *e)
Can all recipients be determined.
Definition: crypt.c:1030
WHERE bool C_ResumeDraftFiles
Config: Process draft files like postponed messages.
Definition: globals.h:254
char * subject
Email&#39;s subject.
Definition: envelope.h:66
Type: &#39;multipart/*&#39;.
Definition: mime.h:37
Log at debug level 1.
Definition: logging.h:56
char * newsgroups
List of newsgroups.
Definition: envelope.h:75
#define MUTT_SEND2_HOOK
send2-hook: when changing fields in the compose menu
Definition: hook.h:56
bool use_disp
Content-Disposition uses filename= ?
Definition: body.h:68
int mutt_file_copy_stream(FILE *fp_in, FILE *fp_out)
Copy the contents of one file into another.
Definition: file.c:268
char * mutt_str_strdup(const char *str)
Copy a string, safely.
Definition: string.c:380
struct Email * email
Email in the list.
Definition: email.h:122
#define mutt_error(...)
Definition: logging.h:84
bool mutt_needs_mailcap(struct Body *m)
Does this type need a mailcap entry do display.
Definition: muttlib.c:405
int mutt_builtin_editor(const char *path, struct Email *e_new, struct Email *e_cur)
Show the user the built-in editor.
Definition: edit.c:402
bool unlink
If true, filename should be unlink()ed before free()ing this structure.
Definition: body.h:69
bool replied
Email has been replied to.
Definition: email.h:56
static int edit_envelope(struct Envelope *en, SendFlags flags)
Edit Envelope fields.
Definition: send.c:244
int mutt_str_strcasecmp(const char *a, const char *b)
Compare two strings ignoring case, safely.
Definition: string.c:628
WHERE char * C_Editor
Config: External command to use as an email editor.
Definition: globals.h:114
void mutt_edit_headers(const char *editor, const char *body, struct Email *e, char *fcc, size_t fcclen)
Let the user edit the message header and body.
Definition: mutt_header.c:168
bool C_UseFrom
Config: Set the &#39;From&#39; header for outgoing mail.
Definition: send.c:136
time_t mutt_file_decrease_mtime(const char *fp, struct stat *st)
Decrease a file&#39;s modification time by 1 second.
Definition: file.c:959
#define MUTT_REPLY_HOOK
reply-hook: when replying to an email
Definition: hook.h:55
#define FREE(x)
Definition: memory.h:40
char * mutt_param_get(const struct ParameterList *pl, const char *s)
Find a matching Parameter.
Definition: parameter.c:84
#define MUTT_COMPOSE_NOFREEHEADER
Definition: compose.h:36
static int postpone_message(struct Email *e_post, struct Email *e_cur, char *fcc, SendFlags flags)
Save an Email for another day.
Definition: send.c:1740
struct AddressList to
Email&#39;s &#39;To&#39; list.
Definition: envelope.h:58
List of Emails.
Definition: email.h:120
struct Email * email_new(void)
Create a new Email.
Definition: email.c:68
WHERE char * C_Realname
Config: Real name of the user.
Definition: globals.h:143
#define mutt_debug(LEVEL,...)
Definition: logging.h:81
void mutt_message_hook(struct Mailbox *m, struct Email *e, HookFlags type)
Perform a message hook.
Definition: hook.c:579
void mutt_body_free(struct Body **ptr)
Free a Body.
Definition: body.c:57
#define TAILQ_EMPTY(head)
Definition: queue.h:715
WHERE bool OptNewsSend
(pseudo) used to change behavior when posting
Definition: options.h:44
Log at debug level 5.
Definition: logging.h:60
WHERE char * C_PgpSignAs
Config: Use this alternative key for signing messages.
Definition: globals.h:168
FILE * mutt_file_fopen(const char *path, const char *mode)
Call fopen() safely.
Definition: file.c:583
WHERE char * C_SmimeSignAs
Config: Use this alternative key for signing messages.
Definition: globals.h:172
static void append_signature(FILE *fp)
Append a signature to an email.
Definition: send.c:142
void email_free(struct Email **ptr)
Free an Email.
Definition: email.c:41
char * C_ContentType
Config: Default "Content-Type" for newly composed messages.
Definition: send.c:98
Content is inline.
Definition: mime.h:62
struct ParameterList parameter
parameters of the content-type
Definition: body.h:39
struct AddressList x_original_to
Email&#39;s &#39;X-Orig-to&#39;.
Definition: envelope.h:64
#define STAILQ_FIRST(head)
Definition: queue.h:348
#define WithCrypto
Definition: ncrypt.h:160
void mutt_edit_file(const char *editor, const char *file)
Let the user edit a file.
Definition: curs_lib.c:308
int mutt_str_strcmp(const char *a, const char *b)
Compare two strings, safely.
Definition: string.c:615
static int send_message(struct Email *e)
Send an email.
Definition: send.c:1335
Type: &#39;application/*&#39;.
Definition: mime.h:33
QuadOption
Possible values for a quad-option.
Definition: quad.h:35
void mutt_param_set(struct ParameterList *pl, const char *attribute, const char *value)
Set a Parameter.
Definition: parameter.c:110
#define SEND_BATCH
Send email in batch mode (without user interaction)
Definition: send.h:92
int mutt_get_postponed(struct Context *ctx, struct Email *hdr, struct Email **cur, char *fcc, size_t fcclen)
Recall a postponed message.
Definition: postpone.c:290
bool C_CryptReplysignencrypted
Config: Sign replies to encrypted messages.
Definition: send.c:105
bool C_NmRecord
Config: (notmuch) If the &#39;record&#39; mailbox (sent mail) should be indexed.
Definition: send.c:122
void mutt_addrlist_append(struct AddressList *al, struct Address *a)
Append an Address to an AddressList.
Definition: address.c:1401
#define APPLICATION_SMIME
Use SMIME to encrypt/sign.
Definition: ncrypt.h:135
bool C_CryptAutopgp
Config: Allow automatic PGP functions.
Definition: send.c:100
bool C_CryptAutoencrypt
Config: Automatically PGP encrypt all outgoing mail.
Definition: send.c:99
bool C_ReplyWithXorig
Config: Create &#39;From&#39; header from &#39;X-Original-To&#39; header.
Definition: send.c:130
+ Here is the caller graph for this function:

◆ mutt_add_to_reference_headers()

void mutt_add_to_reference_headers ( struct Envelope env,
struct Envelope curenv 
)

Generate references for a reply email.

Parameters
envEnvelope for result
curenvEnvelope of source email

Definition at line 951 of file send.c.

952 {
953  add_references(&env->references, curenv);
954  add_message_id(&env->references, curenv);
955  add_message_id(&env->in_reply_to, curenv);
956 
957 #ifdef USE_NNTP
958  if (OptNewsSend && C_XCommentTo && !TAILQ_EMPTY(&curenv->from))
960 #endif
961 }
#define TAILQ_FIRST(head)
Definition: queue.h:717
static void add_references(struct ListHead *head, struct Envelope *env)
Add the email&#39;s references to a list.
Definition: send.c:857
static void add_message_id(struct ListHead *head, struct Envelope *env)
Add the email&#39;s message ID to a list.
Definition: send.c:873
struct ListHead in_reply_to
in-reply-to header content
Definition: envelope.h:82
struct AddressList from
Email&#39;s &#39;From&#39; list.
Definition: envelope.h:57
char * x_comment_to
List of &#39;X-comment-to&#39; fields.
Definition: envelope.h:78
char * mutt_str_strdup(const char *str)
Copy a string, safely.
Definition: string.c:380
WHERE bool C_XCommentTo
Config: (nntp) Add &#39;X-Comment-To&#39; header that contains article author.
Definition: globals.h:294
#define TAILQ_EMPTY(head)
Definition: queue.h:715
WHERE bool OptNewsSend
(pseudo) used to change behavior when posting
Definition: options.h:44
struct ListHead references
message references (in reverse order)
Definition: envelope.h:81
const char * mutt_get_name(const struct Address *a)
Pick the best name to display from an address.
Definition: sort.c:155
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_default_from()

struct Address* mutt_default_from ( void  )

Get a default 'from' Address.

Return values
ptrNewly allocated Address

Definition at line 1307 of file send.c.

1308 {
1309  /* Note: We let $from override $realname here.
1310  * Is this the right thing to do?
1311  */
1312 
1313  if (C_From)
1314  {
1315  return mutt_addr_copy(C_From);
1316  }
1317  else if (C_UseDomain)
1318  {
1319  struct Address *addr = mutt_addr_new();
1320  mutt_str_asprintf(&addr->mailbox, "%s@%s", NONULL(Username), NONULL(mutt_fqdn(true)));
1321  return addr;
1322  }
1323  else
1324  {
1325  return mutt_addr_create(NULL, Username);
1326  }
1327 }
WHERE char * Username
User&#39;s login name.
Definition: globals.h:52
#define NONULL(x)
Definition: string2.h:37
struct Address * mutt_addr_new(void)
Create a new Address.
Definition: address.c:384
An email address.
Definition: address.h:34
char * mailbox
Mailbox and host address.
Definition: address.h:37
struct Address * mutt_addr_copy(const struct Address *addr)
Copy the real address.
Definition: address.c:706
struct Address * mutt_addr_create(const char *personal, const char *mailbox)
Create and populate a new Address.
Definition: address.c:397
WHERE bool C_UseDomain
Config: Qualify local addresses using this domain.
Definition: globals.h:270
WHERE struct Address * C_From
Config: Default &#39;From&#39; address to use, if isn&#39;t otherwise set.
Definition: globals.h:99
const char * mutt_fqdn(bool may_hide_host)
Get the Fully-Qualified Domain Name.
Definition: sendlib.c:2527
int mutt_str_asprintf(char **strp, const char *fmt,...)
Definition: string.c:1195
+ 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]alAddressList to edit
[in]fieldPrompt for user
[in]expand_aliasesIf true, expand Address aliases
Return values
0Success
-1Failure

Definition at line 210 of file send.c.

211 {
212  char buf[8192];
213  char *err = NULL;
214  int idna_ok = 0;
215 
216  do
217  {
218  buf[0] = '\0';
220  mutt_addrlist_write(buf, sizeof(buf), al, false);
221  if (mutt_get_field(field, buf, sizeof(buf), MUTT_ALIAS) != 0)
222  return -1;
224  mutt_addrlist_parse2(al, buf);
225  if (expand_aliases)
227  idna_ok = mutt_addrlist_to_intl(al, &err);
228  if (idna_ok != 0)
229  {
230  mutt_error(_("Bad IDN: '%s'"), err);
231  FREE(&err);
232  }
233  } while (idna_ok != 0);
234  return 0;
235 }
void mutt_expand_aliases(struct AddressList *al)
Expand aliases in a List of Addresses.
Definition: alias.c:304
#define MUTT_ALIAS
Do alias "completion" by calling up the alias-menu.
Definition: mutt.h:65
int mutt_addrlist_to_local(struct AddressList *al)
Convert an Address list from Punycode.
Definition: address.c:1298
void mutt_addrlist_clear(struct AddressList *al)
Unlink and free all Address in an AddressList.
Definition: address.c:1381
#define _(a)
Definition: message.h:28
size_t mutt_addrlist_write(char *buf, size_t buflen, const struct AddressList *al, bool display)
Write an Address to a buffer.
Definition: address.c:1137
int mutt_addrlist_parse2(struct AddressList *al, const char *s)
Parse a list of email addresses.
Definition: address.c:606
#define mutt_get_field(field, buf, buflen, complete)
Definition: curs_lib.h:86
int mutt_addrlist_to_intl(struct AddressList *al, char **err)
Convert an Address list to Punycode.
Definition: address.c:1216
#define mutt_error(...)
Definition: logging.h:84
#define FREE(x)
Definition: memory.h:40
+ 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 
)

rfc2047 encode the content-descriptions

Parameters
bBody of email
recurseIf true, encode children parts

Definition at line 1410 of file send.c.

1411 {
1412  for (struct Body *t = b; t; t = t->next)
1413  {
1414  if (t->description)
1415  {
1416  rfc2047_encode(&t->description, NULL, sizeof("Content-Description:"), C_SendCharset);
1417  }
1418  if (recurse && t->parts)
1419  mutt_encode_descriptions(t->parts, recurse);
1420  }
1421 }
struct Body * next
next attachment in the list
Definition: body.h:53
The body of an email.
Definition: body.h:34
char * C_SendCharset
Config: Character sets for outgoing mail.
Definition: email_globals.c:38
void mutt_encode_descriptions(struct Body *b, bool recurse)
rfc2047 encode the content-descriptions
Definition: send.c:1410
void rfc2047_encode(char **pd, const char *specials, int col, const char *charsets)
RFC-2047-encode a string.
Definition: rfc2047.c:625
+ 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 
)

Generate recpients for a reply email.

Parameters
outEnvelope to populate
inEnvelope of source email
flagsFlags, see SendFlags
Return values
0Success
-1Failure

Definition at line 802 of file send.c.

803 {
804  enum QuadOption hmfupto = MUTT_ABORT;
805  const struct Address *followup_to = TAILQ_FIRST(&in->mail_followup_to);
806 
807  if ((flags & (SEND_LIST_REPLY | SEND_GROUP_REPLY | SEND_GROUP_CHAT_REPLY)) && followup_to)
808  {
809  char prompt[256];
810  snprintf(prompt, sizeof(prompt), _("Follow-up to %s%s?"), followup_to->mailbox,
811  TAILQ_NEXT(TAILQ_FIRST(&in->mail_followup_to), entries) ? ",..." : "");
812 
813  hmfupto = query_quadoption(C_HonorFollowupTo, prompt);
814  if (hmfupto == MUTT_ABORT)
815  return -1;
816  }
817 
818  if (flags & SEND_LIST_REPLY)
819  {
820  add_mailing_lists(&out->to, &in->to, &in->cc);
821 
822  if (followup_to && (hmfupto == MUTT_YES) &&
823  (default_to(&out->cc, in, flags & SEND_LIST_REPLY, (hmfupto == MUTT_YES)) == MUTT_ABORT))
824  {
825  return -1; /* abort */
826  }
827  }
828  else if (flags & SEND_TO_SENDER)
829  {
830  mutt_addrlist_copy(&out->to, &in->from, false);
831  }
832  else
833  {
834  if (default_to(&out->to, in, flags & (SEND_GROUP_REPLY | SEND_GROUP_CHAT_REPLY),
835  (hmfupto == MUTT_YES)) == -1)
836  return -1; /* abort */
837 
838  if ((flags & (SEND_GROUP_REPLY | SEND_GROUP_CHAT_REPLY)) &&
839  (!followup_to || (hmfupto != MUTT_YES)))
840  {
841  /* if(!mutt_addr_is_user(in->to)) */
842  if (flags & SEND_GROUP_REPLY)
843  mutt_addrlist_copy(&out->cc, &in->to, true);
844  else
845  mutt_addrlist_copy(&out->to, &in->cc, true);
846  mutt_addrlist_copy(&out->cc, &in->cc, true);
847  }
848  }
849  return 0;
850 }
#define SEND_TO_SENDER
Compose new email to sender.
Definition: send.h:99
#define TAILQ_FIRST(head)
Definition: queue.h:717
struct AddressList mail_followup_to
Email&#39;s &#39;mail-followup-to&#39;.
Definition: envelope.h:63
User aborted the question (with Ctrl-G)
Definition: quad.h:37
enum QuadOption query_quadoption(enum QuadOption opt, const char *prompt)
Ask the user a quad-question.
Definition: init.c:3331
User answered &#39;Yes&#39;, or assume &#39;Yes&#39;.
Definition: quad.h:39
void mutt_addrlist_copy(struct AddressList *dst, const struct AddressList *src, bool prune)
Copy a list of addresses into another list.
Definition: address.c:727
#define _(a)
Definition: message.h:28
An email address.
Definition: address.h:34
char * mailbox
Mailbox and host address.
Definition: address.h:37
static int default_to(struct AddressList *to, struct Envelope *env, SendFlags flags, int hmfupto)
Generate default email addresses.
Definition: send.c:721
unsigned char C_HonorFollowupTo
Config: Honour the &#39;Mail-Followup-To&#39; header when group replying.
Definition: send.c:118
struct AddressList from
Email&#39;s &#39;From&#39; list.
Definition: envelope.h:57
struct AddressList cc
Email&#39;s &#39;Cc&#39; list.
Definition: envelope.h:59
#define SEND_LIST_REPLY
Reply to mailing list.
Definition: send.h:89
#define SEND_GROUP_REPLY
Reply to all.
Definition: send.h:88
static void add_mailing_lists(struct AddressList *out, const struct AddressList *t, const struct AddressList *c)
Search Address lists for mailing lists.
Definition: send.c:183
struct AddressList to
Email&#39;s &#39;To&#39; list.
Definition: envelope.h:58
#define TAILQ_NEXT(elm, field)
Definition: queue.h:816
#define SEND_GROUP_CHAT_REPLY
Reply to all recipients preserving To/Cc.
Definition: send.h:100
QuadOption
Possible values for a quad-option.
Definition: quad.h:35
+ 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)

Remove duplicate recipients.

Parameters
envEnvelope to fix

Definition at line 885 of file send.c.

886 {
887  if (!C_Metoo)
888  {
889  /* the order is important here. do the CC: first so that if the
890  * the user is the only recipient, it ends up on the TO: field */
891  remove_user(&env->cc, TAILQ_EMPTY(&env->to));
892  remove_user(&env->to, TAILQ_EMPTY(&env->cc) || C_ReplySelf);
893  }
894 
895  /* the CC field can get cluttered, especially with lists */
896  mutt_addrlist_dedupe(&env->to);
897  mutt_addrlist_dedupe(&env->cc);
898  mutt_addrlist_remove_xrefs(&env->to, &env->cc);
899 
900  if (!TAILQ_EMPTY(&env->cc) && TAILQ_EMPTY(&env->to))
901  {
902  TAILQ_SWAP(&env->to, &env->cc, Address, entries);
903  }
904 }
bool C_ReplySelf
Config: Really reply to yourself, when replying to your own email.
Definition: send.c:128
An email address.
Definition: address.h:34
void mutt_addrlist_dedupe(struct AddressList *al)
Remove duplicate addresses.
Definition: address.c:1318
struct AddressList cc
Email&#39;s &#39;Cc&#39; list.
Definition: envelope.h:59
bool C_Metoo
Config: Remove the user&#39;s address from the list of recipients.
Definition: send.c:121
void mutt_addrlist_remove_xrefs(const struct AddressList *a, struct AddressList *b)
Remove cross-references.
Definition: address.c:1354
struct AddressList to
Email&#39;s &#39;To&#39; list.
Definition: envelope.h:58
#define TAILQ_EMPTY(head)
Definition: queue.h:715
static void remove_user(struct AddressList *al, bool leave_only)
Remove any address which matches the current user.
Definition: send.c:164
#define TAILQ_SWAP(head1, head2, type, field)
Definition: queue.h:839
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_forward_intro()

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

Add the "start of forwarded message" text.

Parameters
mMailbox
eEmail
fpFile to write to

Definition at line 432 of file send.c.

433 {
434  if (!C_ForwardAttributionIntro || !fp)
435  return;
436 
437  char buf[1024];
438  setlocale(LC_TIME, NONULL(C_AttributionLocale));
439  mutt_make_string(buf, sizeof(buf), C_ForwardAttributionIntro, NULL, m, e);
440  setlocale(LC_TIME, "");
441  fputs(buf, fp);
442  fputs("\n\n", fp);
443 }
#define NONULL(x)
Definition: string2.h:37
char * C_ForwardAttributionIntro
Config: Prefix message for forwarded messages.
Definition: send.c:112
WHERE char * C_AttributionLocale
Config: Locale for dates in the attribution message.
Definition: globals.h:103
#define mutt_make_string(BUF, BUFLEN, S, CTX, M, E)
Definition: hdrline.h:61
+ Here is the caller graph for this function:

◆ mutt_forward_trailer()

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

Add a "end of forwarded message" text.

Parameters
mMailbox
eEmail
fpFile to write to

Definition at line 451 of file send.c.

452 {
453  if (!C_ForwardAttributionTrailer || !fp)
454  return;
455 
456  char buf[1024];
457  setlocale(LC_TIME, NONULL(C_AttributionLocale));
458  mutt_make_string(buf, sizeof(buf), C_ForwardAttributionTrailer, NULL, m, e);
459  setlocale(LC_TIME, "");
460  fputc('\n', fp);
461  fputs(buf, fp);
462  fputc('\n', fp);
463 }
#define NONULL(x)
Definition: string2.h:37
WHERE char * C_AttributionLocale
Config: Locale for dates in the attribution message.
Definition: globals.h:103
char * C_ForwardAttributionTrailer
Config: Suffix message for forwarded messages.
Definition: send.c:113
#define mutt_make_string(BUF, BUFLEN, S, CTX, M, E)
Definition: hdrline.h:61
+ Here is the caller graph for this function:

◆ mutt_make_attribution()

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

Add "on DATE, PERSON wrote" header.

Parameters
mMailbox
eEmail
fp_outFile to write to

Definition at line 641 of file send.c.

642 {
643  if (!C_Attribution || !fp_out)
644  return;
645 
646  char buf[1024];
647  setlocale(LC_TIME, NONULL(C_AttributionLocale));
648  mutt_make_string(buf, sizeof(buf), C_Attribution, NULL, m, e);
649  setlocale(LC_TIME, "");
650  fputs(buf, fp_out);
651  fputc('\n', fp_out);
652 }
#define NONULL(x)
Definition: string2.h:37
WHERE char * C_AttributionLocale
Config: Locale for dates in the attribution message.
Definition: globals.h:103
#define mutt_make_string(BUF, BUFLEN, S, CTX, M, E)
Definition: hdrline.h:61
WHERE char * C_Attribution
Config: Message to start a reply, "On DATE, PERSON wrote:".
Definition: globals.h:102
+ Here is the caller graph for this function:

◆ mutt_make_forward_subject()

void mutt_make_forward_subject ( struct Envelope env,
struct Mailbox m,
struct Email e 
)

Create a subject for a forwarded email.

Parameters
envEnvelope for result
mMailbox
eEmail

Definition at line 912 of file send.c.

913 {
914  if (!env)
915  return;
916 
917  char buf[256];
918 
919  /* set the default subject for the message. */
920  mutt_make_string(buf, sizeof(buf), NONULL(C_ForwardFormat), NULL, m, e);
921  mutt_str_replace(&env->subject, buf);
922 }
#define NONULL(x)
Definition: string2.h:37
char * C_ForwardFormat
Config: printf-like format string to control the subject when forwarding a message.
Definition: send.c:115
void mutt_str_replace(char **p, const char *s)
Replace one string with another.
Definition: string.c:453
char * subject
Email&#39;s subject.
Definition: envelope.h:66
#define mutt_make_string(BUF, BUFLEN, S, CTX, M, E)
Definition: hdrline.h:61
+ 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 curenv 
)

Set subject for a reply.

Parameters
envEnvelope for result
curenvEnvelope of source email

Definition at line 929 of file send.c.

930 {
931  if (!env || !curenv)
932  return;
933 
934  /* This takes precedence over a subject that might have
935  * been taken from a List-Post header. Is that correct? */
936  if (curenv->real_subj)
937  {
938  FREE(&env->subject);
939  env->subject = mutt_mem_malloc(mutt_str_strlen(curenv->real_subj) + 5);
940  sprintf(env->subject, "Re: %s", curenv->real_subj);
941  }
942  else if (!env->subject)
944 }
char * real_subj
Offset of the real subject.
Definition: envelope.h:67
size_t mutt_str_strlen(const char *a)
Calculate the length of a string, safely.
Definition: string.c:666
void * mutt_mem_malloc(size_t size)
Allocate memory on the heap.
Definition: memory.c:90
char * subject
Email&#39;s subject.
Definition: envelope.h:66
char * mutt_str_strdup(const char *str)
Copy a string, safely.
Definition: string.c:380
#define FREE(x)
Definition: memory.h:40
char * C_EmptySubject
Config: Subject to use when replying to an email with none.
Definition: send.c:106
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_make_post_indent()

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

Add suffix to replied email text.

Parameters
mMailbox
eEmail
fp_outFile to write to

Definition at line 660 of file send.c.

661 {
662  if (!C_PostIndentString || !fp_out)
663  return;
664 
665  char buf[256];
666  mutt_make_string(buf, sizeof(buf), C_PostIndentString, NULL, m, e);
667  fputs(buf, fp_out);
668  fputc('\n', fp_out);
669 }
#define mutt_make_string(BUF, BUFLEN, S, CTX, M, E)
Definition: hdrline.h:61
char * C_PostIndentString
Config: Suffix message to add after reply text.
Definition: send.c:124
+ Here is the caller graph for this function:

◆ mutt_remove_xrefs()

struct Address* mutt_remove_xrefs ( struct Address a,
struct Address b 
)

◆ mutt_resend_message()

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

Resend an email.

Parameters
fpFile containing email
ctxMailbox
e_curEmail to resend
Return values
0Message was successfully sent
-1Message was aborted or an error occurred
1Message was postponed

Definition at line 1467 of file send.c.

1468 {
1469  struct Email *e_new = email_new();
1470 
1471  if (mutt_prepare_template(fp, ctx->mailbox, e_new, e_cur, true) < 0)
1472  {
1473  email_free(&e_new);
1474  return -1;
1475  }
1476 
1477  if (WithCrypto)
1478  {
1479  /* mutt_prepare_template doesn't always flip on an application bit.
1480  * so fix that here */
1481  if (!(e_new->security & (APPLICATION_SMIME | APPLICATION_PGP)))
1482  {
1483  if (((WithCrypto & APPLICATION_SMIME) != 0) && C_SmimeIsDefault)
1484  e_new->security |= APPLICATION_SMIME;
1485  else if (WithCrypto & APPLICATION_PGP)
1486  e_new->security |= APPLICATION_PGP;
1487  else
1488  e_new->security |= APPLICATION_SMIME;
1489  }
1490 
1492  {
1493  e_new->security |= SEC_OPPENCRYPT;
1495  }
1496  }
1497 
1498  struct EmailList el = STAILQ_HEAD_INITIALIZER(el);
1499  el_add_email(&el, e_cur);
1500  int rc = ci_send_message(SEND_RESEND, e_new, NULL, ctx, &el);
1501  emaillist_clear(&el);
1502 
1503  return rc;
1504 }
The envelope/body of an email.
Definition: email.h:39
WHERE bool C_SmimeIsDefault
Config: Use SMIME rather than PGP by default.
Definition: globals.h:284
struct Mailbox * mailbox
Definition: context.h:50
void emaillist_clear(struct EmailList *el)
Drop a private list of Emails.
Definition: email.c:127
int el_add_email(struct EmailList *el, struct Email *e)
Get a list of the selected Emails.
Definition: context.c:398
#define SEND_RESEND
Reply using the current email as a template.
Definition: send.h:95
WHERE bool C_CryptOpportunisticEncrypt
Config: Enable encryption when the recipient&#39;s key is available.
Definition: globals.h:280
int ci_send_message(SendFlags flags, struct Email *e_templ, const char *tempfile, struct Context *ctx, struct EmailList *el)
Send an email.
Definition: send.c:1837
SecurityFlags security
bit 0-10: flags, bit 11,12: application, bit 13: traditional pgp See: ncrypt/ncrypt.h pgplib.h, smime.h
Definition: email.h:41
#define SEC_OPPENCRYPT
Opportunistic encrypt mode.
Definition: ncrypt.h:130
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: ncrypt.h:134
void crypt_opportunistic_encrypt(struct Email *e)
Can all recipients be determined.
Definition: crypt.c:1030
#define STAILQ_HEAD_INITIALIZER(head)
Definition: queue.h:322
struct Email * email_new(void)
Create a new Email.
Definition: email.c:68
void email_free(struct Email **ptr)
Free an Email.
Definition: email.c:41
#define WithCrypto
Definition: ncrypt.h:160
int mutt_prepare_template(FILE *fp, struct Mailbox *m, struct Email *e_new, struct Email *e, bool resend)
Prepare a message template.
Definition: postpone.c:596
#define APPLICATION_SMIME
Use SMIME to encrypt/sign.
Definition: ncrypt.h:135
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_set_followup_to()

void mutt_set_followup_to ( struct Envelope env)

Set followup-to field.

Parameters
envEnvelope to modify

Definition at line 1187 of file send.c.

1188 {
1189  /* Only generate the Mail-Followup-To if the user has requested it, and
1190  * it hasn't already been set */
1191 
1192  if (!C_FollowupTo)
1193  return;
1194 #ifdef USE_NNTP
1195  if (OptNewsSend)
1196  {
1197  if (!env->followup_to && env->newsgroups && (strrchr(env->newsgroups, ',')))
1198  env->followup_to = mutt_str_strdup(env->newsgroups);
1199  return;
1200  }
1201 #endif
1202 
1203  if (TAILQ_EMPTY(&env->mail_followup_to))
1204  {
1205  if (mutt_is_list_recipient(false, env))
1206  {
1207  /* this message goes to known mailing lists, so create a proper
1208  * mail-followup-to header */
1209 
1210  mutt_addrlist_copy(&env->mail_followup_to, &env->to, false);
1211  mutt_addrlist_copy(&env->mail_followup_to, &env->cc, true);
1212  }
1213 
1214  /* remove ourselves from the mail-followup-to header */
1215  remove_user(&env->mail_followup_to, false);
1216 
1217  /* If we are not subscribed to any of the lists in question, re-add
1218  * ourselves to the mail-followup-to header. The mail-followup-to header
1219  * generated is a no-op with group-reply, but makes sure list-reply has the
1220  * desired effect. */
1221 
1222  if (!TAILQ_EMPTY(&env->mail_followup_to) &&
1223  !mutt_is_subscribed_list_recipient(false, env))
1224  {
1225  struct AddressList *al = NULL;
1226  if (!TAILQ_EMPTY(&env->reply_to))
1227  al = &env->reply_to;
1228  else if (!TAILQ_EMPTY(&env->from))
1229  al = &env->from;
1230 
1231  if (al)
1232  {
1233  struct Address *a = NULL;
1234  TAILQ_FOREACH_REVERSE(a, al, AddressList, entries)
1235  {
1237  }
1238  }
1239  else
1240  {
1242  }
1243  }
1244 
1246  }
1247 }
struct AddressList mail_followup_to
Email&#39;s &#39;mail-followup-to&#39;.
Definition: envelope.h:63
struct AddressList reply_to
Email&#39;s &#39;reply-to&#39;.
Definition: envelope.h:62
void mutt_addrlist_copy(struct AddressList *dst, const struct AddressList *src, bool prune)
Copy a list of addresses into another list.
Definition: address.c:727
An email address.
Definition: address.h:34
bool C_FollowupTo
Config: Add the &#39;Mail-Followup-To&#39; header is generated when sending mail.
Definition: send.c:111
struct Address * mutt_addr_copy(const struct Address *addr)
Copy the real address.
Definition: address.c:706
void mutt_addrlist_dedupe(struct AddressList *al)
Remove duplicate addresses.
Definition: address.c:1318
#define TAILQ_FOREACH_REVERSE(var, head, headname, field)
Definition: queue.h:739
struct AddressList from
Email&#39;s &#39;From&#39; list.
Definition: envelope.h:57
struct AddressList cc
Email&#39;s &#39;Cc&#39; list.
Definition: envelope.h:59
struct Address * mutt_default_from(void)
Get a default &#39;from&#39; Address.
Definition: send.c:1307
void mutt_addrlist_prepend(struct AddressList *al, struct Address *a)
Prepend an Address to an AddressList.
Definition: address.c:1412
char * newsgroups
List of newsgroups.
Definition: envelope.h:75
char * mutt_str_strdup(const char *str)
Copy a string, safely.
Definition: string.c:380
char * followup_to
List of &#39;followup-to&#39; fields.
Definition: envelope.h:77
int mutt_is_subscribed_list_recipient(bool all_addr, struct Envelope *e)
Matches subscribed mailing lists.
Definition: pattern.c:1768
struct AddressList to
Email&#39;s &#39;To&#39; list.
Definition: envelope.h:58
#define TAILQ_EMPTY(head)
Definition: queue.h:715
WHERE bool OptNewsSend
(pseudo) used to change behavior when posting
Definition: options.h:44
static void remove_user(struct AddressList *al, bool leave_only)
Remove any address which matches the current user.
Definition: send.c:164
int mutt_is_list_recipient(bool all_addr, struct Envelope *e)
Matches known mailing lists.
Definition: pattern.c:1780
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

Variable Documentation

◆ C_AbortNoattach

unsigned char C_AbortNoattach

Config: Abort sending the email if attachments are missing.

Definition at line 92 of file send.c.

◆ C_AbortNoattachRegex

struct Regex* C_AbortNoattachRegex

Config: Regex to match text indicating attachments are expected.

Definition at line 93 of file send.c.

◆ C_AbortNosubject

unsigned char C_AbortNosubject

Config: Abort creating the email if subject is missing.

Definition at line 94 of file send.c.

◆ C_AbortUnmodified

unsigned char C_AbortUnmodified

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

Definition at line 95 of file send.c.

◆ C_AskFollowUp

bool C_AskFollowUp

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

Definition at line 96 of file send.c.

◆ C_AskXCommentTo

bool C_AskXCommentTo

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

Definition at line 97 of file send.c.

◆ C_ContentType

char* C_ContentType

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

Definition at line 98 of file send.c.

◆ C_CryptAutoencrypt

bool C_CryptAutoencrypt

Config: Automatically PGP encrypt all outgoing mail.

Definition at line 99 of file send.c.

◆ C_CryptAutopgp

bool C_CryptAutopgp

Config: Allow automatic PGP functions.

Definition at line 100 of file send.c.

◆ C_CryptAutosign

bool C_CryptAutosign

Config: Automatically PGP sign all outgoing mail.

Definition at line 101 of file send.c.

◆ C_CryptAutosmime

bool C_CryptAutosmime

Config: Allow automatic SMIME functions.

Definition at line 102 of file send.c.

◆ C_CryptReplyencrypt

bool C_CryptReplyencrypt

Config: Encrypt replies to encrypted messages.

Definition at line 103 of file send.c.

◆ C_CryptReplysign

bool C_CryptReplysign

Config: Sign replies to signed messages.

Definition at line 104 of file send.c.

◆ C_CryptReplysignencrypted

bool C_CryptReplysignencrypted

Config: Sign replies to encrypted messages.

Definition at line 105 of file send.c.

◆ C_EmptySubject

char* C_EmptySubject

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

Definition at line 106 of file send.c.

◆ C_FastReply

bool C_FastReply

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

Definition at line 107 of file send.c.

◆ C_FccAttach

unsigned char C_FccAttach

Config: Save send message with all their attachments.

Definition at line 108 of file send.c.

◆ C_FccBeforeSend

bool C_FccBeforeSend

Config: Save FCCs before sending the message.

Definition at line 109 of file send.c.

◆ C_FccClear

bool C_FccClear

Config: Save sent messages unencrypted and unsigned.

Definition at line 110 of file send.c.

◆ C_FollowupTo

bool C_FollowupTo

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

Definition at line 111 of file send.c.

◆ C_ForwardAttributionIntro

char* C_ForwardAttributionIntro

Config: Prefix message for forwarded messages.

Definition at line 112 of file send.c.

◆ C_ForwardAttributionTrailer

char* C_ForwardAttributionTrailer

Config: Suffix message for forwarded messages.

Definition at line 113 of file send.c.

◆ C_ForwardEdit

unsigned char C_ForwardEdit

Config: Automatically start the editor when forwarding a message.

Definition at line 114 of file send.c.

◆ C_ForwardFormat

char* C_ForwardFormat

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

Definition at line 115 of file send.c.

◆ C_ForwardReferences

bool C_ForwardReferences

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

Definition at line 116 of file send.c.

◆ C_Hdrs

bool C_Hdrs

Config: Add custom headers to outgoing mail.

Definition at line 117 of file send.c.

◆ C_HonorFollowupTo

unsigned char C_HonorFollowupTo

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

Definition at line 118 of file send.c.

◆ C_IgnoreListReplyTo

bool C_IgnoreListReplyTo

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

Definition at line 119 of file send.c.

◆ C_Include

unsigned char C_Include

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

Definition at line 120 of file send.c.

◆ C_Metoo

bool C_Metoo

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

Definition at line 121 of file send.c.

◆ C_NmRecord

bool C_NmRecord

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

Definition at line 122 of file send.c.

◆ C_PgpReplyinline

bool C_PgpReplyinline

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

Definition at line 123 of file send.c.

◆ C_PostIndentString

char* C_PostIndentString

Config: Suffix message to add after reply text.

Definition at line 124 of file send.c.

◆ C_PostponeEncrypt

bool C_PostponeEncrypt

Config: Self-encrypt postponed messages.

Definition at line 125 of file send.c.

◆ C_PostponeEncryptAs

char* C_PostponeEncryptAs

Config: Fallback encryption key for postponed messages.

Definition at line 126 of file send.c.

◆ C_Recall

unsigned char C_Recall

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

Definition at line 127 of file send.c.

◆ C_ReplySelf

bool C_ReplySelf

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

Definition at line 128 of file send.c.

◆ C_ReplyTo

unsigned char C_ReplyTo

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

Definition at line 129 of file send.c.

◆ C_ReplyWithXorig

bool C_ReplyWithXorig

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

Definition at line 130 of file send.c.

◆ C_ReverseName

bool C_ReverseName

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

Definition at line 131 of file send.c.

◆ C_ReverseRealname

bool C_ReverseRealname

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

Definition at line 132 of file send.c.

◆ C_SigDashes

bool C_SigDashes

Config: Insert '– ' before the signature.

Definition at line 133 of file send.c.

◆ C_Signature

char* C_Signature

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

Definition at line 134 of file send.c.

◆ C_SigOnTop

bool C_SigOnTop

Config: Insert the signature before the quoted text.

Definition at line 135 of file send.c.

◆ C_UseFrom

bool C_UseFrom

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

Definition at line 136 of file send.c.