NeoMutt  2019-12-07-60-g0cfa53
Teaching an old dog new tricks
DOXYGEN
send.c File Reference

Prepare and send an email. More...

#include "config.h"
#include <errno.h>
#include <locale.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 "address/lib.h"
#include "config/lib.h"
#include "email/lib.h"
#include "core/lib.h"
#include "gui/lib.h"
#include "mutt.h"
#include "send.h"
#include "alias.h"
#include "compose.h"
#include "context.h"
#include "copy.h"
#include "edit.h"
#include "filter.h"
#include "globals.h"
#include "handler.h"
#include "hdrline.h"
#include "hook.h"
#include "mutt_attach.h"
#include "mutt_body.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 "recvattach.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 "autocrypt/autocrypt.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 void remove_user (struct AddressList *al, bool leave_only)
 Remove any address which matches the current user. More...
 
static void add_mailing_lists (struct AddressList *out, const struct AddressList *t, const struct AddressList *c)
 Search Address lists for mailing lists. More...
 
int mutt_edit_address (struct AddressList *al, const char *field, bool expand_aliases)
 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...
 
static int inline_forward_attachments (struct Mailbox *m, struct Email *e, struct Body ***plast, int *forwardq)
 Add attachments to an email, inline. More...
 
static int mutt_inline_forward (struct Mailbox *m, struct Email *e_edit, struct Email *e_cur, FILE *out)
 Forward attachments, inline. 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 const struct AddressList * choose_default_to (const struct Address *from, const struct Envelope *env)
 Pick the best 'to:' value. More...
 
static int default_to (struct AddressList *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 *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_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 *e, 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 void set_reverse_name (struct AddressList *al, struct Envelope *env)
 Try to set the 'from' field from the recipients. More...
 
struct Addressmutt_default_from (void)
 Get a default 'from' Address. More...
 
static int send_message (struct Email *e)
 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 *e_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 *e, struct Buffer *fcc, 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 *e_post, struct Email *e_cur, const char *fcc, SendFlags flags)
 Save an Email for another day. More...
 
int ci_send_message (SendFlags flags, struct Email *e_templ, 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 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
  • Michael R. Elkins
  • Pietro Cerutti

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

◆ append_signature()

static void append_signature ( FILE *  fp)
static

Append a signature to an email.

Parameters
fpFile to write to

Definition at line 140 of file send.c.

141 {
142  FILE *fp_tmp = NULL;
143  pid_t pid;
144 
145  if (C_Signature && (fp_tmp = mutt_open_read(C_Signature, &pid)))
146  {
147  if (C_SigDashes)
148  fputs("\n-- \n", fp);
149  mutt_file_copy_stream(fp_tmp, fp);
150  mutt_file_fclose(&fp_tmp);
151  if (pid != -1)
152  mutt_wait_filter(pid);
153  }
154 }
bool C_SigDashes
Config: Insert &#39;– &#39; before the signature.
Definition: send.c:131
int mutt_file_fclose(FILE **fp)
Close a FILE handle (and NULL the pointer)
Definition: file.c:152
int mutt_file_copy_stream(FILE *fp_in, FILE *fp_out)
Copy the contents of one file into another.
Definition: file.c:270
int mutt_wait_filter(pid_t pid)
Wait for the exit of a process and return its status.
Definition: filter.c:220
FILE * mutt_open_read(const char *path, pid_t *thepid)
Run a command to read from.
Definition: muttlib.c:1403
char * C_Signature
Config: File containing a signature to append to all mail.
Definition: send.c:132
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ remove_user()

static void remove_user ( struct AddressList *  al,
bool  leave_only 
)
static

Remove any address which matches the current user.

Parameters
alList of addresses
leave_onlyIf set, don't remove the user's address if it it the only one in the list

Definition at line 162 of file send.c.

163 {
164  struct Address *a = NULL, *tmp = NULL;
165  TAILQ_FOREACH_SAFE(a, al, entries, tmp)
166  {
167  if (mutt_addr_is_user(a) && (!leave_only || TAILQ_NEXT(a, entries)))
168  {
169  TAILQ_REMOVE(al, a, entries);
170  mutt_addr_free(&a);
171  }
172  }
173 }
#define TAILQ_FOREACH_SAFE(var, head, field, tvar)
Definition: queue.h:728
An email address.
Definition: address.h:34
void mutt_addr_free(struct Address **ptr)
Free a single Address.
Definition: address.c:440
#define TAILQ_REMOVE(head, elm, field)
Definition: queue.h:834
bool mutt_addr_is_user(const struct Address *addr)
Does the address belong to the user.
Definition: alias.c:682
#define TAILQ_NEXT(elm, field)
Definition: queue.h:825
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ add_mailing_lists()

static void add_mailing_lists ( struct AddressList *  out,
const struct AddressList *  t,
const struct AddressList *  c 
)
static

Search Address lists for mailing lists.

Parameters
outAddress list where to append matching mailing lists
t'To' Address list
c'Cc' Address list

Definition at line 181 of file send.c.

183 {
184  const struct AddressList *const als[] = { t, c };
185 
186  for (size_t i = 0; i < mutt_array_size(als); ++i)
187  {
188  const struct AddressList *al = als[i];
189  struct Address *a = NULL;
190  TAILQ_FOREACH(a, al, entries)
191  {
192  if (!a->group && mutt_is_mail_list(a))
193  {
195  }
196  }
197  }
198 }
#define TAILQ_FOREACH(var, head, field)
Definition: queue.h:718
bool mutt_is_mail_list(const struct Address *addr)
Is this the email address of a mailing list?
Definition: hdrline.c:114
An email address.
Definition: address.h:34
struct Address * mutt_addr_copy(const struct Address *addr)
Copy the real address.
Definition: address.c:707
#define mutt_array_size(x)
Definition: memory.h:33
bool group
Group mailbox?
Definition: address.h:38
void mutt_addrlist_append(struct AddressList *al, struct Address *a)
Append an Address to an AddressList.
Definition: address.c:1402
+ 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 208 of file send.c.

209 {
210  char buf[8192];
211  char *err = NULL;
212  int idna_ok = 0;
213 
214  do
215  {
216  buf[0] = '\0';
218  mutt_addrlist_write(al, buf, sizeof(buf), false);
219  if (mutt_get_field(field, buf, sizeof(buf), MUTT_ALIAS) != 0)
220  return -1;
222  mutt_addrlist_parse2(al, buf);
223  if (expand_aliases)
225  idna_ok = mutt_addrlist_to_intl(al, &err);
226  if (idna_ok != 0)
227  {
228  mutt_error(_("Bad IDN: '%s'"), err);
229  FREE(&err);
230  }
231  } while (idna_ok != 0);
232  return 0;
233 }
void mutt_expand_aliases(struct AddressList *al)
Expand aliases in a List of Addresses.
Definition: alias.c:303
#define MUTT_ALIAS
Do alias "completion" by calling up the alias-menu.
Definition: mutt.h:63
int mutt_addrlist_to_local(struct AddressList *al)
Convert an Address list from Punycode.
Definition: address.c:1299
void mutt_addrlist_clear(struct AddressList *al)
Unlink and free all Address in an AddressList.
Definition: address.c:1382
#define _(a)
Definition: message.h:28
int mutt_addrlist_parse2(struct AddressList *al, const char *s)
Parse a list of email addresses.
Definition: address.c:607
#define mutt_get_field(field, buf, buflen, complete)
Definition: curs_lib.h:92
int mutt_addrlist_to_intl(struct AddressList *al, char **err)
Convert an Address list to Punycode.
Definition: address.c:1217
#define mutt_error(...)
Definition: logging.h:84
#define FREE(x)
Definition: memory.h:40
size_t mutt_addrlist_write(const struct AddressList *al, char *buf, size_t buflen, bool display)
Write an Address to a buffer.
Definition: address.c:1138
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ edit_envelope()

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

Edit Envelope fields.

Parameters
enEnvelope to edit
flagsFlags, see SendFlags
Return values
0Success
-1Failure

Definition at line 242 of file send.c.

243 {
244  char buf[8192];
245 
246 #ifdef USE_NNTP
247  if (OptNewsSend)
248  {
249  if (en->newsgroups)
250  mutt_str_strfcpy(buf, en->newsgroups, sizeof(buf));
251  else
252  buf[0] = '\0';
253  if (mutt_get_field("Newsgroups: ", buf, sizeof(buf), 0) != 0)
254  return -1;
255  FREE(&en->newsgroups);
256  en->newsgroups = mutt_str_strdup(buf);
257 
258  if (en->followup_to)
259  mutt_str_strfcpy(buf, en->followup_to, sizeof(buf));
260  else
261  buf[0] = '\0';
262  if (C_AskFollowUp && (mutt_get_field("Followup-To: ", buf, sizeof(buf), 0) != 0))
263  {
264  return -1;
265  }
266  FREE(&en->followup_to);
267  en->followup_to = mutt_str_strdup(buf);
268 
269  if (en->x_comment_to)
270  mutt_str_strfcpy(buf, en->x_comment_to, sizeof(buf));
271  else
272  buf[0] = '\0';
273  if (C_XCommentTo && C_AskXCommentTo &&
274  (mutt_get_field("X-Comment-To: ", buf, sizeof(buf), 0) != 0))
275  {
276  return -1;
277  }
278  FREE(&en->x_comment_to);
279  en->x_comment_to = mutt_str_strdup(buf);
280  }
281  else
282 #endif
283  {
284  if ((mutt_edit_address(&en->to, _("To: "), true) == -1) || TAILQ_EMPTY(&en->to))
285  return -1;
286  if (C_Askcc && (mutt_edit_address(&en->cc, _("Cc: "), true) == -1))
287  return -1;
288  if (C_Askbcc && (mutt_edit_address(&en->bcc, _("Bcc: "), true) == -1))
289  return -1;
291  (mutt_edit_address(&en->from, "From: ", true) == -1))
292  {
293  return -1;
294  }
295  }
296 
297  if (en->subject)
298  {
299  if (C_FastReply)
300  return 0;
301  mutt_str_strfcpy(buf, en->subject, sizeof(buf));
302  }
303  else
304  {
305  const char *p = NULL;
306 
307  buf[0] = '\0';
308  struct ListNode *uh = NULL;
309  STAILQ_FOREACH(uh, &UserHeader, entries)
310  {
311  size_t plen = mutt_str_startswith(uh->data, "subject:", CASE_IGNORE);
312  if (plen)
313  {
314  p = mutt_str_skip_email_wsp(uh->data + plen);
315  mutt_str_strfcpy(buf, p, sizeof(buf));
316  }
317  }
318  }
319 
320  if ((mutt_get_field(_("Subject: "), buf, sizeof(buf), 0) != 0) ||
321  (!buf[0] &&
322  (query_quadoption(C_AbortNosubject, _("No subject, abort?")) != MUTT_NO)))
323  {
324  mutt_message(_("No subject, aborting"));
325  return -1;
326  }
327  mutt_str_replace(&en->subject, buf);
328 
329  return 0;
330 }
enum QuadOption query_quadoption(enum QuadOption opt, const char *prompt)
Ask the user a quad-question.
Definition: init.c:3360
#define mutt_message(...)
Definition: logging.h:83
struct AddressList bcc
Email&#39;s &#39;Bcc&#39; list.
Definition: envelope.h:60
static size_t plen
Length of cached packet.
Definition: pgppacket.c:39
#define _(a)
Definition: message.h:28
#define mutt_get_field(field, buf, buflen, complete)
Definition: curs_lib.h:92
unsigned char C_AbortNosubject
Config: Abort creating the email if subject is missing.
Definition: send.c:92
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:90
bool C_FastReply
Config: Don&#39;t prompt for the recipients and subject when replying/forwarding.
Definition: send.c:105
char * x_comment_to
List of &#39;X-comment-to&#39; fields.
Definition: envelope.h:78
bool C_AskXCommentTo
Config: (nntp) Ask the user for the &#39;X-Comment-To&#39; field before editing.
Definition: send.c:95
User answered &#39;No&#39;, or assume &#39;No&#39;.
Definition: quad.h:39
size_t mutt_str_strfcpy(char *dest, const char *src, size_t dsize)
Copy a string into a buffer (guaranteeing NUL-termination)
Definition: string.c:750
Ignore case when comparing strings.
Definition: string2.h:68
char * mutt_str_skip_email_wsp(const char *s)
Skip over whitespace as defined by RFC5322.
Definition: string.c:776
#define STAILQ_FOREACH(var, head, field)
Definition: queue.h:349
#define SEND_REPLY
Reply to sender.
Definition: send.h:88
void mutt_str_replace(char **p, const char *s)
Replace one string with another.
Definition: string.c:453
bool C_AskFollowUp
Config: (nntp) Ask the user for follow-up groups before editing.
Definition: send.c:94
size_t mutt_str_startswith(const char *str, const char *prefix, enum CaseSensitivity cs)
Check whether a string starts with a prefix.
Definition: string.c:168
#define SEND_GROUP_REPLY
Reply to all.
Definition: send.h:89
char * data
String.
Definition: list.h:35
char * subject
Email&#39;s subject.
Definition: envelope.h:66
char * newsgroups
List of newsgroups.
Definition: envelope.h:75
WHERE bool C_XCommentTo
Config: (nntp) Add &#39;X-Comment-To&#39; header that contains article author.
Definition: globals.h:283
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
#define FREE(x)
Definition: memory.h:40
struct AddressList to
Email&#39;s &#39;To&#39; list.
Definition: envelope.h:58
#define TAILQ_EMPTY(head)
Definition: queue.h:714
WHERE bool OptNewsSend
(pseudo) used to change behavior when posting
Definition: options.h:44
A List node for strings.
Definition: list.h:33
WHERE bool C_Askbcc
Config: Ask the user for the blind-carbon-copy recipients.
Definition: globals.h:195
int mutt_edit_address(struct AddressList *al, const char *field, bool expand_aliases)
Edit an email address.
Definition: send.c:208
WHERE bool C_Askcc
Config: Ask the user for the carbon-copy recipients.
Definition: globals.h:196
bool C_ReplyWithXorig
Config: Create &#39;From&#39; header from &#39;X-Original-To&#39; header.
Definition: send.c:128
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ nntp_get_header()

static char* nntp_get_header ( const char *  s)
static

Get the trimmed header.

Parameters
sHeader line with leading whitespace
Return values
ptrCopy of string
Note
The caller should free the returned string.

Definition at line 340 of file send.c.

341 {
342  SKIPWS(s);
343  return mutt_str_strdup(s);
344 }
#define SKIPWS(ch)
Definition: string2.h:47
char * mutt_str_strdup(const char *str)
Copy a string, safely.
Definition: string.c:380
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ process_user_recips()

static void process_user_recips ( struct Envelope env)
static

Process the user headers.

Parameters
envEnvelope to populate

Definition at line 351 of file send.c.

352 {
353  struct ListNode *uh = NULL;
354  STAILQ_FOREACH(uh, &UserHeader, entries)
355  {
356  size_t plen;
357  if ((plen = mutt_str_startswith(uh->data, "to:", CASE_IGNORE)))
358  mutt_addrlist_parse(&env->to, uh->data + plen);
359  else if ((plen = mutt_str_startswith(uh->data, "cc:", CASE_IGNORE)))
360  mutt_addrlist_parse(&env->cc, uh->data + plen);
361  else if ((plen = mutt_str_startswith(uh->data, "bcc:", CASE_IGNORE)))
362  mutt_addrlist_parse(&env->bcc, uh->data + plen);
363 #ifdef USE_NNTP
364  else if ((plen = mutt_str_startswith(uh->data, "newsgroups:", CASE_IGNORE)))
365  env->newsgroups = nntp_get_header(uh->data + plen);
366  else if ((plen = mutt_str_startswith(uh->data, "followup-to:", CASE_IGNORE)))
367  env->followup_to = nntp_get_header(uh->data + plen);
368  else if ((plen = mutt_str_startswith(uh->data, "x-comment-to:", CASE_IGNORE)))
369  env->x_comment_to = nntp_get_header(uh->data + plen);
370 #endif
371  }
372 }
int mutt_addrlist_parse(struct AddressList *al, const char *s)
Parse a list of email addresses.
Definition: address.c:458
struct AddressList bcc
Email&#39;s &#39;Bcc&#39; list.
Definition: envelope.h:60
static char * nntp_get_header(const char *s)
Get the trimmed header.
Definition: send.c:340
static size_t plen
Length of cached packet.
Definition: pgppacket.c:39
struct AddressList cc
Email&#39;s &#39;Cc&#39; list.
Definition: envelope.h:59
char * x_comment_to
List of &#39;X-comment-to&#39; fields.
Definition: envelope.h:78
Ignore case when comparing strings.
Definition: string2.h:68
#define STAILQ_FOREACH(var, head, field)
Definition: queue.h:349
size_t mutt_str_startswith(const char *str, const char *prefix, enum CaseSensitivity cs)
Check whether a string starts with a prefix.
Definition: string.c:168
char * data
String.
Definition: list.h:35
char * newsgroups
List of newsgroups.
Definition: envelope.h:75
char * followup_to
List of &#39;followup-to&#39; fields.
Definition: envelope.h:77
struct AddressList to
Email&#39;s &#39;To&#39; list.
Definition: envelope.h:58
A List node for strings.
Definition: list.h:33
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ process_user_header()

static void process_user_header ( struct Envelope env)
static

Process the user headers.

Parameters
envEnvelope to populate

Definition at line 378 of file send.c.

379 {
380  struct ListNode *uh = NULL;
381  STAILQ_FOREACH(uh, &UserHeader, entries)
382  {
383  size_t plen;
384  if ((plen = mutt_str_startswith(uh->data, "from:", CASE_IGNORE)))
385  {
386  /* User has specified a default From: address. Remove default address */
387  mutt_addrlist_clear(&env->from);
388  mutt_addrlist_parse(&env->from, uh->data + plen);
389  }
390  else if ((plen = mutt_str_startswith(uh->data, "reply-to:", CASE_IGNORE)))
391  {
393  mutt_addrlist_parse(&env->reply_to, uh->data + plen);
394  }
395  else if ((plen = mutt_str_startswith(uh->data, "message-id:", CASE_IGNORE)))
396  {
397  char *tmp = mutt_extract_message_id(uh->data + plen, NULL);
398  if (mutt_addr_valid_msgid(tmp))
399  {
400  FREE(&env->message_id);
401  env->message_id = tmp;
402  }
403  else
404  FREE(&tmp);
405  }
406  else if (!mutt_str_startswith(uh->data, "to:", CASE_IGNORE) &&
407  !mutt_str_startswith(uh->data, "cc:", CASE_IGNORE) &&
408  !mutt_str_startswith(uh->data, "bcc:", CASE_IGNORE) &&
409 #ifdef USE_NNTP
410  !mutt_str_startswith(uh->data, "newsgroups:", CASE_IGNORE) &&
411  !mutt_str_startswith(uh->data, "followup-to:", CASE_IGNORE) &&
412  !mutt_str_startswith(uh->data, "x-comment-to:", CASE_IGNORE) &&
413 #endif
414  !mutt_str_startswith(uh->data, "supersedes:", CASE_IGNORE) &&
415  !mutt_str_startswith(uh->data, "subject:", CASE_IGNORE) &&
416  !mutt_str_startswith(uh->data, "return-path:", CASE_IGNORE))
417  {
419  }
420  }
421 }
struct AddressList reply_to
Email&#39;s &#39;reply-to&#39;.
Definition: envelope.h:62
int mutt_addrlist_parse(struct AddressList *al, const char *s)
Parse a list of email addresses.
Definition: address.c:458
void mutt_addrlist_clear(struct AddressList *al)
Unlink and free all Address in an AddressList.
Definition: address.c:1382
static size_t plen
Length of cached packet.
Definition: pgppacket.c:39
struct ListHead userhdrs
user defined headers
Definition: envelope.h:83
char * message_id
Message ID.
Definition: envelope.h:69
struct AddressList from
Email&#39;s &#39;From&#39; list.
Definition: envelope.h:57
struct ListNode * mutt_list_insert_tail(struct ListHead *h, char *s)
Append a string to the end of a List.
Definition: list.c:65
Ignore case when comparing strings.
Definition: string2.h:68
#define STAILQ_FOREACH(var, head, field)
Definition: queue.h:349
size_t mutt_str_startswith(const char *str, const char *prefix, enum CaseSensitivity cs)
Check whether a string starts with a prefix.
Definition: string.c:168
char * data
String.
Definition: list.h:35
char * mutt_str_strdup(const char *str)
Copy a string, safely.
Definition: string.c:380
bool mutt_addr_valid_msgid(const char *msgid)
Is this a valid Message ID?
Definition: address.c:755
#define FREE(x)
Definition: memory.h:40
A List node for strings.
Definition: list.h:33
char * mutt_extract_message_id(const char *s, const char **saveptr)
Find a message-id.
Definition: parse.c:359
+ 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 429 of file send.c.

430 {
431  if (!C_ForwardAttributionIntro || !fp)
432  return;
433 
434  char buf[1024];
435  setlocale(LC_TIME, NONULL(C_AttributionLocale));
436  mutt_make_string(buf, sizeof(buf), 0, C_ForwardAttributionIntro, NULL, m, e);
437  setlocale(LC_TIME, "");
438  fputs(buf, fp);
439  fputs("\n\n", fp);
440 }
#define NONULL(x)
Definition: string2.h:37
char * C_ForwardAttributionIntro
Config: Prefix message for forwarded messages.
Definition: send.c:110
WHERE char * C_AttributionLocale
Config: Locale for dates in the attribution message.
Definition: globals.h:98
#define mutt_make_string(BUF, BUFLEN, COLS, 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 448 of file send.c.

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

◆ include_forward()

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

Write out a forwarded message.

Parameters
mMailbox
eEmail
fp_outFile to write to
Return values
0Success
-1Failure

Definition at line 470 of file send.c.

471 {
472  CopyHeaderFlags chflags = CH_DECODE;
474 
477 
478  if ((WithCrypto != 0) && (e->security & SEC_ENCRYPT) && C_ForwardDecode)
479  {
480  /* make sure we have the user's passphrase before proceeding... */
482  return -1;
483  }
484 
485  mutt_forward_intro(m, e, fp_out);
486 
487  if (C_ForwardDecode)
488  {
489  cmflags |= MUTT_CM_DECODE | MUTT_CM_CHARCONV;
490  if (C_Weed)
491  {
492  chflags |= CH_WEED | CH_REORDER;
493  cmflags |= MUTT_CM_WEED;
494  }
495  }
496  if (C_ForwardQuote)
497  cmflags |= MUTT_CM_PREFIX;
498 
499  mutt_copy_message(fp_out, m, e, cmflags, chflags, 0);
500  mutt_forward_trailer(m, e, fp_out);
501  return 0;
502 }
WHERE bool C_ForwardDecode
Config: Decode the message when forwarding it.
Definition: globals.h:212
void mutt_forward_intro(struct Mailbox *m, struct Email *e, FILE *fp)
Add the "start of forwarded message" text.
Definition: send.c:429
#define MUTT_CM_WEED
Weed message/rfc822 attachment headers.
Definition: copy.h:40
void mutt_parse_mime_message(struct Mailbox *m, struct Email *e)
Parse a MIME email.
Definition: mutt_parse.c:49
int mutt_copy_message(FILE *fp_out, struct Mailbox *m, struct Email *e, CopyMessageFlags cmflags, CopyHeaderFlags chflags, int wraplen)
Copy a message from a Mailbox.
Definition: copy.c:810
#define MUTT_MESSAGE_HOOK
message-hook: run before displaying a message
Definition: hook.h:52
uint16_t CopyMessageFlags
Flags for mutt_copy_message(), e.g. MUTT_CM_NOHEADER.
Definition: copy.h:31
#define SEC_ENCRYPT
Email is encrypted.
Definition: ncrypt.h:122
#define MUTT_CM_NO_FLAGS
No flags are set.
Definition: copy.h:34
bool crypt_valid_passphrase(SecurityFlags flags)
Check that we have a usable passphrase, ask if not.
Definition: crypt.c:145
#define CH_WEED
Weed the headers?
Definition: copy.h:52
#define MUTT_CM_PREFIX
Quote the header and body.
Definition: copy.h:36
#define MUTT_CM_DECODE
Decode the message body into text/plain.
Definition: copy.h:37
#define CH_REORDER
Re-order output of headers (specified by &#39;hdr_order&#39;)
Definition: copy.h:58
#define MUTT_CM_CHARCONV
Perform character set conversions.
Definition: copy.h:41
#define CH_DECODE
Do RFC2047 header decoding.
Definition: copy.h:53
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:39
void mutt_forward_trailer(struct Mailbox *m, struct Email *e, FILE *fp)
Add a "end of forwarded message" text.
Definition: send.c:448
uint32_t CopyHeaderFlags
Flags for mutt_copy_header(), e.g. CH_UPDATE.
Definition: copy.h:49
WHERE bool C_ForwardQuote
Config: Automatically quote a forwarded message using C_IndentString.
Definition: globals.h:213
void mutt_message_hook(struct Mailbox *m, struct Email *e, HookFlags type)
Perform a message hook.
Definition: hook.c:573
#define WithCrypto
Definition: ncrypt.h:160
bool C_Weed
Config: Filter headers when displaying/forwarding/printing/replying.
Definition: email_globals.c:40
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ inline_forward_attachments()

static int inline_forward_attachments ( struct Mailbox m,
struct Email e,
struct Body ***  plast,
int *  forwardq 
)
static

Add attachments to an email, inline.

Parameters
[in]mMailbox
[in]eCurrent Email
[out]plastPointer to the last Attachment
[out]forwardqResult of asking the user to forward the attachments, e.g. MUTT_YES
Return values
0Success
-1Error

Definition at line 513 of file send.c.

515 {
516  struct Body **last = *plast;
517  struct Body *body = NULL;
518  struct Message *msg = NULL;
519  struct AttachCtx *actx = NULL;
520  int rc = 0, i;
521 
524 
525  msg = mx_msg_open(m, e->msgno);
526  if (!msg)
527  return -1;
528 
529  actx = mutt_mem_calloc(1, sizeof(*actx));
530  actx->email = e;
531  actx->fp_root = msg->fp;
532 
533  mutt_generate_recvattach_list(actx, actx->email, actx->email->content,
534  actx->fp_root, -1, 0, 0);
535 
536  for (i = 0; i < actx->idxlen; i++)
537  {
538  body = actx->idx[i]->content;
539  if ((body->type != TYPE_MULTIPART) && !mutt_can_decode(body) &&
540  !((body->type == TYPE_APPLICATION) &&
541  ((mutt_str_strcasecmp(body->subtype, "pgp-signature") == 0) ||
542  (mutt_str_strcasecmp(body->subtype, "x-pkcs7-signature") == 0) ||
543  (mutt_str_strcasecmp(body->subtype, "pkcs7-signature") == 0))))
544  {
545  /* Ask the quadoption only once */
546  if (*forwardq == -1)
547  {
549  /* L10N:
550  This is the prompt for $forward_attachments.
551  When inline forwarding ($mime_forward answered "no"), this prompts
552  whether to add non-decodable attachments from the original email.
553  Text/plain parts and the like will already be included in the
554  message contents, but other attachment, such as PDF files, will also
555  be added as attachments to the new mail, if this is answered yes.
556  */
557  _("Forward attachments?"));
558  if (*forwardq != MUTT_YES)
559  {
560  if (*forwardq == -1)
561  rc = -1;
562  goto cleanup;
563  }
564  }
565  if (mutt_body_copy(actx->idx[i]->fp, last, body) == -1)
566  {
567  rc = -1;
568  goto cleanup;
569  }
570  last = &((*last)->next);
571  }
572  }
573 
574 cleanup:
575  *plast = last;
576  mx_msg_close(m, &msg);
577  mutt_actx_free(&actx);
578  return rc;
579 }
void mutt_actx_free(struct AttachCtx **ptr)
Free an Attachment Context.
Definition: attach.c:140
void * mutt_mem_calloc(size_t nmemb, size_t size)
Allocate zeroed memory on the heap.
Definition: memory.c:50
void mutt_generate_recvattach_list(struct AttachCtx *actx, struct Email *e, struct Body *parts, FILE *fp, int parent_type, int level, bool decrypted)
Create a list of attachments.
Definition: recvattach.c:1219
enum QuadOption query_quadoption(enum QuadOption opt, const char *prompt)
Ask the user a quad-question.
Definition: init.c:3360
struct Email * email
Used by recvattach for updating.
Definition: attach.h:51
User answered &#39;Yes&#39;, or assume &#39;Yes&#39;.
Definition: quad.h:40
struct Body * content
List of MIME parts.
Definition: email.h:90
FILE * fp_root
Used by recvattach for updating.
Definition: attach.h:52
void mutt_parse_mime_message(struct Mailbox *m, struct Email *e)
Parse a MIME email.
Definition: mutt_parse.c:49
#define _(a)
Definition: message.h:28
short idxlen
Number of attachmentes.
Definition: attach.h:55
#define MUTT_MESSAGE_HOOK
message-hook: run before displaying a message
Definition: hook.h:52
The body of an email.
Definition: body.h:34
int mx_msg_close(struct Mailbox *m, struct Message **msg)
Close a message.
Definition: mx.c:1140
int mutt_body_copy(FILE *fp, struct Body **tgt, struct Body *src)
Create a send-mode duplicate from a receive-mode body.
Definition: mutt_body.c:48
char * subtype
content-type subtype
Definition: body.h:37
A local copy of an email.
Definition: mx.h:81
bool mutt_can_decode(struct Body *a)
Will decoding the attachment produce any output.
Definition: handler.c:1754
FILE * fp
Used in the recvattach menu.
Definition: attach.h:37
unsigned int type
content-type primary type
Definition: body.h:65
Type: &#39;multipart/*&#39;.
Definition: mime.h:37
struct Body * content
Attachment.
Definition: attach.h:36
int mutt_str_strcasecmp(const char *a, const char *b)
Compare two strings ignoring case, safely.
Definition: string.c:628
FILE * fp
pointer to the message data
Definition: mx.h:83
void mutt_message_hook(struct Mailbox *m, struct Email *e, HookFlags type)
Perform a message hook.
Definition: hook.c:573
A set of attachments.
Definition: attach.h:49
struct AttachPtr ** idx
Array of attachments.
Definition: attach.h:54
struct Message * mx_msg_open(struct Mailbox *m, int msgno)
return a stream pointer for a message
Definition: mx.c:1092
Type: &#39;application/*&#39;.
Definition: mime.h:33
int msgno
Number displayed to the user.
Definition: email.h:86
WHERE unsigned char C_ForwardAttachments
Config: Forward attachments when forwarding a message.
Definition: globals.h:181
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_inline_forward()

static int mutt_inline_forward ( struct Mailbox m,
struct Email e_edit,
struct Email e_cur,
FILE *  out 
)
static

Forward attachments, inline.

Parameters
mMailbox
e_editEmail to alter
e_curCurrent Email
outFile
Return values
0Success
-1Error

Definition at line 590 of file send.c.

592 {
593  int forwardq = -1;
594  struct Body **last = NULL;
595 
596  if (e_cur)
597  include_forward(m, e_cur, out);
598  else
599  {
600  for (int i = 0; i < m->vcount; i++)
601  {
602  struct Email *e = mutt_get_virt_email(m, i);
603  if (!e)
604  continue;
605  if (e->tagged)
606  include_forward(m, e, out);
607  }
608  }
609 
611  {
612  last = &e_edit->content;
613  while (*last)
614  last = &((*last)->next);
615 
616  if (e_cur)
617  {
618  if (inline_forward_attachments(m, e_cur, &last, &forwardq) != 0)
619  return -1;
620  }
621  else
622  {
623  for (int i = 0; i < m->vcount; i++)
624  {
625  struct Email *e = mutt_get_virt_email(m, i);
626  if (!e)
627  continue;
628  if (e->tagged)
629  {
630  if (inline_forward_attachments(m, e, &last, &forwardq) != 0)
631  return -1;
632  if (forwardq == MUTT_NO)
633  break;
634  }
635  }
636  }
637  }
638 
639  return 0;
640 }
The envelope/body of an email.
Definition: email.h:37
struct Email * mutt_get_virt_email(struct Mailbox *m, int vnum)
Get a virtual Email.
Definition: context.c:414
WHERE bool C_ForwardDecode
Config: Decode the message when forwarding it.
Definition: globals.h:212
struct Body * content
List of MIME parts.
Definition: email.h:90
static int inline_forward_attachments(struct Mailbox *m, struct Email *e, struct Body ***plast, int *forwardq)
Add attachments to an email, inline.
Definition: send.c:513
int vcount
The number of virtual messages.
Definition: mailbox.h:101
The body of an email.
Definition: body.h:34
bool tagged
Email is tagged.
Definition: email.h:44
static int include_forward(struct Mailbox *m, struct Email *e, FILE *fp_out)
Write out a forwarded message.
Definition: send.c:470
User answered &#39;No&#39;, or assume &#39;No&#39;.
Definition: quad.h:39
WHERE unsigned char C_ForwardAttachments
Config: Forward attachments when forwarding a message.
Definition: globals.h:181
+ Here is the call graph for this function:
+ 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 648 of file send.c.

649 {
650  if (!C_Attribution || !fp_out)
651  return;
652 
653  char buf[1024];
654  setlocale(LC_TIME, NONULL(C_AttributionLocale));
655  mutt_make_string(buf, sizeof(buf), 0, C_Attribution, NULL, m, e);
656  setlocale(LC_TIME, "");
657  fputs(buf, fp_out);
658  fputc('\n', fp_out);
659 }
#define NONULL(x)
Definition: string2.h:37
WHERE char * C_AttributionLocale
Config: Locale for dates in the attribution message.
Definition: globals.h:98
#define mutt_make_string(BUF, BUFLEN, COLS, 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:97
+ 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 667 of file send.c.

668 {
669  if (!C_PostIndentString || !fp_out)
670  return;
671 
672  char buf[256];
673  mutt_make_string(buf, sizeof(buf), 0, C_PostIndentString, NULL, m, e);
674  fputs(buf, fp_out);
675  fputc('\n', fp_out);
676 }
#define mutt_make_string(BUF, BUFLEN, COLS, S, CTX, M, E)
Definition: hdrline.h:61
char * C_PostIndentString
Config: Suffix message to add after reply text.
Definition: send.c:122
+ Here is the caller graph for this function:

◆ include_reply()

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

Generate the reply text for an email.

Parameters
mMailbox
eEmail
fp_outFile to write to
Return values
0Success
-1Failure

Definition at line 686 of file send.c.

687 {
688  CopyMessageFlags cmflags =
690  CopyHeaderFlags chflags = CH_DECODE;
691 
692  if ((WithCrypto != 0) && (e->security & SEC_ENCRYPT))
693  {
694  /* make sure we have the user's passphrase before proceeding... */
696  return -1;
697  }
698 
701 
702  mutt_make_attribution(m, e, fp_out);
703 
704  if (!C_Header)
705  cmflags |= MUTT_CM_NOHEADER;
706  if (C_Weed)
707  {
708  chflags |= CH_WEED | CH_REORDER;
709  cmflags |= MUTT_CM_WEED;
710  }
711 
712  mutt_copy_message(fp_out, m, e, cmflags, chflags, 0);
713 
714  mutt_make_post_indent(m, e, fp_out);
715 
716  return 0;
717 }
#define MUTT_CM_WEED
Weed message/rfc822 attachment headers.
Definition: copy.h:40
void mutt_parse_mime_message(struct Mailbox *m, struct Email *e)
Parse a MIME email.
Definition: mutt_parse.c:49
int mutt_copy_message(FILE *fp_out, struct Mailbox *m, struct Email *e, CopyMessageFlags cmflags, CopyHeaderFlags chflags, int wraplen)
Copy a message from a Mailbox.
Definition: copy.c:810
#define MUTT_MESSAGE_HOOK
message-hook: run before displaying a message
Definition: hook.h:52
uint16_t CopyMessageFlags
Flags for mutt_copy_message(), e.g. MUTT_CM_NOHEADER.
Definition: copy.h:31
void mutt_make_post_indent(struct Mailbox *m, struct Email *e, FILE *fp_out)
Add suffix to replied email text.
Definition: send.c:667
#define SEC_ENCRYPT
Email is encrypted.
Definition: ncrypt.h:122
#define MUTT_CM_REPLYING
Replying the message.
Definition: copy.h:43
bool crypt_valid_passphrase(SecurityFlags flags)
Check that we have a usable passphrase, ask if not.
Definition: crypt.c:145
#define CH_WEED
Weed the headers?
Definition: copy.h:52
WHERE bool C_Header
Config: Include the message headers in the reply email (Weed applies)
Definition: globals.h:219
#define MUTT_CM_PREFIX
Quote the header and body.
Definition: copy.h:36
#define MUTT_CM_DECODE
Decode the message body into text/plain.
Definition: copy.h:37
#define CH_REORDER
Re-order output of headers (specified by &#39;hdr_order&#39;)
Definition: copy.h:58
#define MUTT_CM_CHARCONV
Perform character set conversions.
Definition: copy.h:41
#define CH_DECODE
Do RFC2047 header decoding.
Definition: copy.h:53
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:39
uint32_t CopyHeaderFlags
Flags for mutt_copy_header(), e.g. CH_UPDATE.
Definition: copy.h:49
void mutt_message_hook(struct Mailbox *m, struct Email *e, HookFlags type)
Perform a message hook.
Definition: hook.c:573
#define MUTT_CM_NOHEADER
Don&#39;t copy the message header.
Definition: copy.h:35
#define WithCrypto
Definition: ncrypt.h:160
bool C_Weed
Config: Filter headers when displaying/forwarding/printing/replying.
Definition: email_globals.c:40
void mutt_make_attribution(struct Mailbox *m, struct Email *e, FILE *fp_out)
Add "on DATE, PERSON wrote" header.
Definition: send.c:648
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ choose_default_to()

static const struct AddressList* choose_default_to ( const struct Address from,
const struct Envelope env 
)
static

Pick the best 'to:' value.

Parameters
fromFrom Address
envEnvelope
Return values
ptrAddresses to use

Definition at line 725 of file send.c.

727 {
728  if (!C_ReplySelf && mutt_addr_is_user(from))
729  {
730  /* mail is from the user, assume replying to recipients */
731  return &env->to;
732  }
733  else
734  {
735  return &env->from;
736  }
737 }
bool C_ReplySelf
Config: Really reply to yourself, when replying to your own email.
Definition: send.c:126
struct AddressList from
Email&#39;s &#39;From&#39; list.
Definition: envelope.h:57
bool mutt_addr_is_user(const struct Address *addr)
Does the address belong to the user.
Definition: alias.c:682
struct AddressList to
Email&#39;s &#39;To&#39; list.
Definition: envelope.h:58
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ default_to()

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

Generate default email addresses.

Parameters
[in,out]to'To' address
[in]envEnvelope to populate
[in]flagsFlags, see SendFlags
[in]hmfuptoIf true, add 'followup-to' address to 'to' address
Return values
0Success
-1Aborted

Definition at line 748 of file send.c.

749 {
750  char prompt[256];
751  const struct Address *from = TAILQ_FIRST(&env->from);
752  const struct Address *reply_to = TAILQ_FIRST(&env->reply_to);
753 
754  if (flags && !TAILQ_EMPTY(&env->mail_followup_to) && (hmfupto == MUTT_YES))
755  {
756  mutt_addrlist_copy(to, &env->mail_followup_to, true);
757  return 0;
758  }
759 
760  /* Exit now if we're setting up the default Cc list for list-reply
761  * (only set if Mail-Followup-To is present and honoured). */
762  if (flags & SEND_LIST_REPLY)
763  return 0;
764 
765  const struct AddressList *default_to = choose_default_to(from, env);
766 
767  if (reply_to)
768  {
769  const bool from_is_reply_to = mutt_addr_cmp(from, reply_to);
770  const bool multiple_reply_to =
771  reply_to && TAILQ_NEXT(TAILQ_FIRST(&env->reply_to), entries);
772  if ((from_is_reply_to && !multiple_reply_to && !reply_to->personal) ||
773  (C_IgnoreListReplyTo && mutt_is_mail_list(reply_to) &&
774  (mutt_addrlist_search(&env->to, reply_to) || mutt_addrlist_search(&env->cc, reply_to))))
775  {
776  /* If the Reply-To: address is a mailing list, assume that it was
777  * put there by the mailing list, and use the From: address
778  *
779  * We also take the from header if our correspondent has a reply-to
780  * header which is identical to the electronic mail address given
781  * in his From header, and the reply-to has no display-name. */
782  mutt_addrlist_copy(to, &env->from, false);
783  }
784  else if (!(from_is_reply_to && !multiple_reply_to) && (C_ReplyTo != MUTT_YES))
785  {
786  /* There are quite a few mailing lists which set the Reply-To:
787  * header field to the list address, which makes it quite impossible
788  * to send a message to only the sender of the message. This
789  * provides a way to do that. */
790  /* L10N: Asks whether the user respects the reply-to header.
791  If she says no, neomutt will reply to the from header's address instead. */
792  snprintf(prompt, sizeof(prompt), _("Reply to %s%s?"), reply_to->mailbox,
793  multiple_reply_to ? ",..." : "");
794  switch (query_quadoption(C_ReplyTo, prompt))
795  {
796  case MUTT_YES:
797  mutt_addrlist_copy(to, &env->reply_to, false);
798  break;
799 
800  case MUTT_NO:
801  mutt_addrlist_copy(to, default_to, false);
802  break;
803 
804  default:
805  return -1; /* abort */
806  }
807  }
808  else
809  {
810  mutt_addrlist_copy(to, &env->reply_to, false);
811  }
812  }
813  else
814  {
815  mutt_addrlist_copy(to, default_to, false);
816  }
817 
818  return 0;
819 }
#define TAILQ_FIRST(head)
Definition: queue.h:716
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
enum QuadOption query_quadoption(enum QuadOption opt, const char *prompt)
Ask the user a quad-question.
Definition: init.c:3360
User answered &#39;Yes&#39;, or assume &#39;Yes&#39;.
Definition: quad.h:40
bool mutt_is_mail_list(const struct Address *addr)
Is this the email address of a mailing list?
Definition: hdrline.c:114
void mutt_addrlist_copy(struct AddressList *dst, const struct AddressList *src, bool prune)
Copy a list of addresses into another list.
Definition: address.c:728
#define _(a)
Definition: message.h:28
An email address.
Definition: address.h:34
char * mailbox
Mailbox and host address.
Definition: address.h:37
bool C_IgnoreListReplyTo
Config: Ignore the &#39;Reply-To&#39; header when using <reply> on a mailing list.
Definition: send.c:117
static int default_to(struct AddressList *to, struct Envelope *env, SendFlags flags, int hmfupto)
Generate default email addresses.
Definition: send.c:748
unsigned char C_ReplyTo
Config: Address to use as a &#39;Reply-To&#39; header.
Definition: send.c:127
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:90
User answered &#39;No&#39;, or assume &#39;No&#39;.
Definition: quad.h:39
bool mutt_addr_cmp(const struct Address *a, const struct Address *b)
Compare two e-mail addresses.
Definition: address.c:855
bool mutt_addrlist_search(const struct AddressList *haystack, const struct Address *needle)
Search for an e-mail address in a list.
Definition: address.c:872
static const struct AddressList * choose_default_to(const struct Address *from, const struct Envelope *env)
Pick the best &#39;to:&#39; value.
Definition: send.c:725
char * personal
Real name of address.
Definition: address.h:36
struct AddressList to
Email&#39;s &#39;To&#39; list.
Definition: envelope.h:58
#define TAILQ_NEXT(elm, field)
Definition: queue.h:825
#define TAILQ_EMPTY(head)
Definition: queue.h:714
+ 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 829 of file send.c.

830 {
831  enum QuadOption hmfupto = MUTT_ABORT;
832  const struct Address *followup_to = TAILQ_FIRST(&in->mail_followup_to);
833 
834  if ((flags & (SEND_LIST_REPLY | SEND_GROUP_REPLY | SEND_GROUP_CHAT_REPLY)) && followup_to)
835  {
836  char prompt[256];
837  snprintf(prompt, sizeof(prompt), _("Follow-up to %s%s?"), followup_to->mailbox,
838  TAILQ_NEXT(TAILQ_FIRST(&in->mail_followup_to), entries) ? ",..." : "");
839 
840  hmfupto = query_quadoption(C_HonorFollowupTo, prompt);
841  if (hmfupto == MUTT_ABORT)
842  return -1;
843  }
844 
845  if (flags & SEND_LIST_REPLY)
846  {
847  add_mailing_lists(&out->to, &in->to, &in->cc);
848 
849  if (followup_to && (hmfupto == MUTT_YES) &&
850  (default_to(&out->cc, in, flags & SEND_LIST_REPLY, (hmfupto == MUTT_YES)) == MUTT_ABORT))
851  {
852  return -1; /* abort */
853  }
854  }
855  else if (flags & SEND_TO_SENDER)
856  {
857  mutt_addrlist_copy(&out->to, &in->from, false);
858  }
859  else
860  {
861  if (default_to(&out->to, in, flags & (SEND_GROUP_REPLY | SEND_GROUP_CHAT_REPLY),
862  (hmfupto == MUTT_YES)) == -1)
863  return -1; /* abort */
864 
865  if ((flags & (SEND_GROUP_REPLY | SEND_GROUP_CHAT_REPLY)) &&
866  (!followup_to || (hmfupto != MUTT_YES)))
867  {
868  /* if(!mutt_addr_is_user(in->to)) */
869  if (flags & SEND_GROUP_REPLY)
870  mutt_addrlist_copy(&out->cc, &in->to, true);
871  else
872  mutt_addrlist_copy(&out->to, &in->cc, true);
873  mutt_addrlist_copy(&out->cc, &in->cc, true);
874  }
875  }
876  return 0;
877 }
#define SEND_TO_SENDER
Compose new email to sender.
Definition: send.h:100
#define TAILQ_FIRST(head)
Definition: queue.h:716
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:38
enum QuadOption query_quadoption(enum QuadOption opt, const char *prompt)
Ask the user a quad-question.
Definition: init.c:3360
User answered &#39;Yes&#39;, or assume &#39;Yes&#39;.
Definition: quad.h:40
void mutt_addrlist_copy(struct AddressList *dst, const struct AddressList *src, bool prune)
Copy a list of addresses into another list.
Definition: address.c:728
#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:748
unsigned char C_HonorFollowupTo
Config: Honour the &#39;Mail-Followup-To&#39; header when group replying.
Definition: send.c:116
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:90
#define SEND_GROUP_REPLY
Reply to all.
Definition: send.h:89
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:181
struct AddressList to
Email&#39;s &#39;To&#39; list.
Definition: envelope.h:58
#define TAILQ_NEXT(elm, field)
Definition: queue.h:825
#define SEND_GROUP_CHAT_REPLY
Reply to all recipients preserving To/Cc.
Definition: send.h:101
QuadOption
Possible values for a quad-option.
Definition: quad.h:36
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ add_references()

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

Add the email's references to a list.

Parameters
headList of references
envEnvelope of message

Definition at line 884 of file send.c.

885 {
886  struct ListNode *np = NULL;
887 
888  struct ListHead *src = !STAILQ_EMPTY(&env->references) ? &env->references : &env->in_reply_to;
889  STAILQ_FOREACH(np, src, entries)
890  {
892  }
893 }
struct ListHead in_reply_to
in-reply-to header content
Definition: envelope.h:82
struct ListNode * mutt_list_insert_tail(struct ListHead *h, char *s)
Append a string to the end of a List.
Definition: list.c:65
#define STAILQ_FOREACH(var, head, field)
Definition: queue.h:349
char * data
String.
Definition: list.h:35
char * mutt_str_strdup(const char *str)
Copy a string, safely.
Definition: string.c:380
#define STAILQ_EMPTY(head)
Definition: queue.h:345
struct ListHead references
message references (in reverse order)
Definition: envelope.h:81
A List node for strings.
Definition: list.h:33
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ add_message_id()

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

Add the email's message ID to a list.

Parameters
headList of message IDs
envEnvelope of message

Definition at line 900 of file send.c.

901 {
902  if (env->message_id)
903  {
905  }
906 }
char * message_id
Message ID.
Definition: envelope.h:69
struct ListNode * mutt_list_insert_head(struct ListHead *h, char *s)
Insert a string at the beginning of a List.
Definition: list.c:46
char * mutt_str_strdup(const char *str)
Copy a string, safely.
Definition: string.c:380
+ 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 912 of file send.c.

913 {
914  if (!C_Metoo)
915  {
916  /* the order is important here. do the CC: first so that if the
917  * the user is the only recipient, it ends up on the TO: field */
918  remove_user(&env->cc, TAILQ_EMPTY(&env->to));
919  remove_user(&env->to, TAILQ_EMPTY(&env->cc) || C_ReplySelf);
920  }
921 
922  /* the CC field can get cluttered, especially with lists */
923  mutt_addrlist_dedupe(&env->to);
924  mutt_addrlist_dedupe(&env->cc);
925  mutt_addrlist_remove_xrefs(&env->to, &env->cc);
926 
927  if (!TAILQ_EMPTY(&env->cc) && TAILQ_EMPTY(&env->to))
928  {
929  TAILQ_SWAP(&env->to, &env->cc, Address, entries);
930  }
931 }
bool C_ReplySelf
Config: Really reply to yourself, when replying to your own email.
Definition: send.c:126
An email address.
Definition: address.h:34
void mutt_addrlist_dedupe(struct AddressList *al)
Remove duplicate addresses.
Definition: address.c:1319
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:119
void mutt_addrlist_remove_xrefs(const struct AddressList *a, struct AddressList *b)
Remove cross-references.
Definition: address.c:1355
struct AddressList to
Email&#39;s &#39;To&#39; list.
Definition: envelope.h:58
#define TAILQ_EMPTY(head)
Definition: queue.h:714
static void remove_user(struct AddressList *al, bool leave_only)
Remove any address which matches the current user.
Definition: send.c:162
#define TAILQ_SWAP(head1, head2, type, field)
Definition: queue.h:852
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_make_forward_subject()

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

Create a subject for a forwarded email.

Parameters
envEnvelope for result
mMailbox
eEmail

Definition at line 939 of file send.c.

940 {
941  if (!env)
942  return;
943 
944  char buf[256];
945 
946  /* set the default subject for the message. */
947  mutt_make_string(buf, sizeof(buf), 0, NONULL(C_ForwardFormat), NULL, m, e);
948  mutt_str_replace(&env->subject, buf);
949 }
#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:113
#define mutt_make_string(BUF, BUFLEN, COLS, S, CTX, M, E)
Definition: hdrline.h:61
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
+ 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 956 of file send.c.

957 {
958  if (!env || !curenv)
959  return;
960 
961  /* This takes precedence over a subject that might have
962  * been taken from a List-Post header. Is that correct? */
963  if (curenv->real_subj)
964  {
965  FREE(&env->subject);
966  env->subject = mutt_mem_malloc(mutt_str_strlen(curenv->real_subj) + 5);
967  sprintf(env->subject, "Re: %s", curenv->real_subj);
968  }
969  else if (!env->subject)
971 }
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:104
+ Here is the call graph for this function:
+ 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 978 of file send.c.

979 {
980  add_references(&env->references, curenv);
981  add_message_id(&env->references, curenv);
982  add_message_id(&env->in_reply_to, curenv);
983 
984 #ifdef USE_NNTP
985  if (OptNewsSend && C_XCommentTo && !TAILQ_EMPTY(&curenv->from))
987 #endif
988 }
#define TAILQ_FIRST(head)
Definition: queue.h:716
static void add_references(struct ListHead *head, struct Envelope *env)
Add the email&#39;s references to a list.
Definition: send.c:884
static void add_message_id(struct ListHead *head, struct Envelope *env)
Add the email&#39;s message ID to a list.
Definition: send.c:900
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:283
#define TAILQ_EMPTY(head)
Definition: queue.h:714
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:

◆ make_reference_headers()

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

Generate reference headers for an email.

Parameters
elList of source Emails
envEnvelope for result

Definition at line 995 of file send.c.

996 {
997  if (!el || !env || STAILQ_EMPTY(el))
998  return;
999 
1000  struct EmailNode *en = STAILQ_FIRST(el);
1001  bool single = !STAILQ_NEXT(en, entries);
1002 
1003  if (!single)
1004  {
1005  STAILQ_FOREACH(en, el, entries)
1006  {
1008  }
1009  }
1010  else
1012 
1013  /* if there's more than entry in In-Reply-To (i.e. message has multiple
1014  * parents), don't generate a References: header as it's discouraged by
1015  * RFC2822, sect. 3.6.4 */
1016  if (!single && !STAILQ_EMPTY(&env->in_reply_to) &&
1017  STAILQ_NEXT(STAILQ_FIRST(&env->in_reply_to), entries))
1018  {
1019  mutt_list_free(&env->references);
1020  }
1021 }
void mutt_list_free(struct ListHead *h)
Free a List AND its strings.
Definition: list.c:123
struct ListHead in_reply_to
in-reply-to header content
Definition: envelope.h:82
struct Envelope * env
Envelope information.
Definition: email.h:89
#define STAILQ_FOREACH(var, head, field)
Definition: queue.h:349
#define STAILQ_NEXT(elm, field)
Definition: queue.h:397
struct Email * email
Email in the list.
Definition: email.h:116
#define STAILQ_EMPTY(head)
Definition: queue.h:345
List of Emails.
Definition: email.h:114
struct ListHead references
message references (in reverse order)
Definition: envelope.h:81
#define STAILQ_FIRST(head)
Definition: queue.h:347
void mutt_add_to_reference_headers(struct Envelope *env, struct Envelope *curenv)
Generate references for a reply email.
Definition: send.c:978
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ envelope_defaults()

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
envEnvelope for result
mMailbox
elList of Emails to use
flagsFlags, see SendFlags
Return values
0Success
-1Failure

Definition at line 1032 of file send.c.

1034 {
1035  if (!el || STAILQ_EMPTY(el))
1036  return -1;
1037 
1038  struct EmailNode *en = STAILQ_FIRST(el);
1039  bool single = !STAILQ_NEXT(en, entries);
1040 
1041  struct Envelope *curenv = en->email->env;
1042  if (!curenv)
1043  return -1;
1044 
1045  if (flags & (SEND_REPLY | SEND_TO_SENDER))
1046  {
1047 #ifdef USE_NNTP
1048  if ((flags & SEND_NEWS))
1049  {
1050  /* in case followup set Newsgroups: with Followup-To: if it present */
1051  if (!env->newsgroups &&
1052  (mutt_str_strcasecmp(curenv->followup_to, "poster") != 0))
1053  {
1054  env->newsgroups = mutt_str_strdup(curenv->followup_to);
1055  }
1056  }
1057  else
1058 #endif
1059  if (!single)
1060  {
1061  STAILQ_FOREACH(en, el, entries)
1062  {
1063  if (mutt_fetch_recips(env, en->email->env, flags) == -1)
1064  return -1;
1065  }
1066  }
1067  else if (mutt_fetch_recips(env, curenv, flags) == -1)
1068  return -1;
1069 
1070  if ((flags & SEND_LIST_REPLY) && TAILQ_EMPTY(&env->to))
1071  {
1072  mutt_error(_("No mailing lists found"));
1073  return -1;
1074  }
1075 
1076  if (flags & SEND_REPLY)
1077  {
1078  mutt_make_misc_reply_headers(env, curenv);
1079  make_reference_headers(el, env);
1080  }
1081  }
1082  else if (flags & SEND_FORWARD)
1083  {
1084  mutt_make_forward_subject(env, m, en->email);
1085  if (C_ForwardReferences)
1086  make_reference_headers(el, env);
1087  }
1088 
1089  return 0;
1090 }
static void make_reference_headers(struct EmailList *el, struct Envelope *env)
Generate reference headers for an email.
Definition: send.c:995
#define SEND_TO_SENDER
Compose new email to sender.
Definition: send.h:100
#define SEND_FORWARD
Forward email.
Definition: send.h:91
int mutt_fetch_recips(struct Envelope *out, struct Envelope *in, SendFlags flags)
Generate recpients for a reply email.
Definition: send.c:829
#define _(a)
Definition: message.h:28
void mutt_make_misc_reply_headers(struct Envelope *env, struct Envelope *curenv)
Set subject for a reply.
Definition: send.c:956
struct Envelope * env
Envelope information.
Definition: email.h:89
#define SEND_LIST_REPLY
Reply to mailing list.
Definition: send.h:90
#define SEND_NEWS
Reply to a news article.
Definition: send.h:102
#define STAILQ_FOREACH(var, head, field)
Definition: queue.h:349
#define STAILQ_NEXT(elm, field)
Definition: queue.h:397
#define SEND_REPLY
Reply to sender.
Definition: send.h:88
char * newsgroups
List of newsgroups.
Definition: envelope.h:75
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:116
#define mutt_error(...)
Definition: logging.h:84
char * followup_to
List of &#39;followup-to&#39; fields.
Definition: envelope.h:77
int mutt_str_strcasecmp(const char *a, const char *b)
Compare two strings ignoring case, safely.
Definition: string.c:628
void mutt_make_forward_subject(struct Envelope *env, struct Mailbox *m, struct Email *e)
Create a subject for a forwarded email.
Definition: send.c:939
#define STAILQ_EMPTY(head)
Definition: queue.h:345
struct AddressList to
Email&#39;s &#39;To&#39; list.
Definition: envelope.h:58
List of Emails.
Definition: email.h:114
bool C_ForwardReferences
Config: Set the &#39;In-Reply-To&#39; and &#39;References&#39; headers when forwarding a message. ...
Definition: send.c:114
#define TAILQ_EMPTY(head)
Definition: queue.h:714
#define STAILQ_FIRST(head)
Definition: queue.h:347
The header of an Email.
Definition: envelope.h:54
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ generate_body()

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

Create a new email body.

Parameters
fp_tmpStream for outgoing message
eEmail for outgoing message
flagsCompose mode, see SendFlags
mMailbox
elList of Emails to use
Return values
0Success
-1Error

Definition at line 1102 of file send.c.

1104 {
1105  struct Body *tmp = NULL;
1106  struct EmailNode *en = NULL;
1107  bool single = true;
1108 
1109  if (el)
1110  en = STAILQ_FIRST(el);
1111  if (en)
1112  single = !STAILQ_NEXT(en, entries);
1113 
1114  /* An EmailList is required for replying and forwarding */
1115  if (!el && (flags & (SEND_REPLY | SEND_FORWARD)))
1116  return -1;
1117 
1118  if (flags & SEND_REPLY)
1119  {
1120  enum QuadOption ans =
1121  query_quadoption(C_Include, _("Include message in reply?"));
1122  if (ans == MUTT_ABORT)
1123  return -1;
1124 
1125  if (ans == MUTT_YES)
1126  {
1127  mutt_message(_("Including quoted message..."));
1128  if (single && en)
1129  include_reply(m, en->email, fp_tmp);
1130  else
1131  {
1132  STAILQ_FOREACH(en, el, entries)
1133  {
1134  if (include_reply(m, en->email, fp_tmp) == -1)
1135  {
1136  mutt_error(_("Could not include all requested messages"));
1137  return -1;
1138  }
1139  fputc('\n', fp_tmp);
1140  }
1141  }
1142  }
1143  }
1144  else if (flags & SEND_FORWARD)
1145  {
1146  enum QuadOption ans =
1147  query_quadoption(C_MimeForward, _("Forward as attachment?"));
1148  if (ans == MUTT_YES)
1149  {
1150  struct Body *last = e->content;
1151 
1152  mutt_message(_("Preparing forwarded message..."));
1153 
1154  while (last && last->next)
1155  last = last->next;
1156 
1157  if (single && en)
1158  {
1159  tmp = mutt_make_message_attach(m, en->email, false);
1160  if (last)
1161  last->next = tmp;
1162  else
1163  e->content = tmp;
1164  }
1165  else
1166  {
1167  STAILQ_FOREACH(en, el, entries)
1168  {
1169  tmp = mutt_make_message_attach(m, en->email, false);
1170  if (last)
1171  {
1172  last->next = tmp;
1173  last = tmp;
1174  }
1175  else
1176  {
1177  last = tmp;
1178  e->content = tmp;
1179  }
1180  }
1181  }
1182  }
1183  else if ((ans != MUTT_ABORT) && en)
1184  {
1185  if (mutt_inline_forward(m, e, en->email, fp_tmp) != 0)
1186  return -1;
1187  }
1188  else
1189  return -1;
1190  }
1191  /* if (WithCrypto && (flags & SEND_KEY)) */
1192  else if (((WithCrypto & APPLICATION_PGP) != 0) && (flags & SEND_KEY))
1193  {
1194  struct Body *b = NULL;
1195 
1196  if (((WithCrypto & APPLICATION_PGP) != 0) && !(b = crypt_pgp_make_key_attachment()))
1197  {
1198  return -1;
1199  }
1200 
1201  b->next = e->content;
1202  e->content = b;
1203  }
1204 
1205  mutt_clear_error();
1206 
1207  return 0;
1208 }
struct Body * mutt_make_message_attach(struct Mailbox *m, struct Email *e, bool attach_msg)
Create a message attachment.
Definition: sendlib.c:1516
User aborted the question (with Ctrl-G)
Definition: quad.h:38
enum QuadOption query_quadoption(enum QuadOption opt, const char *prompt)
Ask the user a quad-question.
Definition: init.c:3360
#define mutt_message(...)
Definition: logging.h:83
User answered &#39;Yes&#39;, or assume &#39;Yes&#39;.
Definition: quad.h:40
#define SEND_FORWARD
Forward email.
Definition: send.h:91
struct Body * content
List of MIME parts.
Definition: email.h:90
#define _(a)
Definition: message.h:28
struct Body * next
next attachment in the list
Definition: body.h:53
unsigned char C_Include
Config: Include a copy of the email that&#39;s being replied to.
Definition: send.c:118
The body of an email.
Definition: body.h:34
WHERE unsigned char C_MimeForward
Config: Forward a message as a &#39;message/RFC822&#39; MIME part.
Definition: globals.h:182
void mutt_clear_error(void)
Clear the message line (bottom line of screen)
Definition: mutt_logging.c:113
#define SEND_KEY
Mail a PGP public key.
Definition: send.h:95
static int include_reply(struct Mailbox *m, struct Email *e, FILE *fp_out)
Generate the reply text for an email.
Definition: send.c:686
#define STAILQ_FOREACH(var, head, field)
Definition: queue.h:349
#define STAILQ_NEXT(elm, field)
Definition: queue.h:397
#define SEND_REPLY
Reply to sender.
Definition: send.h:88
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: ncrypt.h:134
struct Body * crypt_pgp_make_key_attachment(void)
Wrapper for CryptModuleSpecs::pgp_make_key_attachment()
Definition: cryptglue.c:299
struct Email * email
Email in the list.
Definition: email.h:116
#define mutt_error(...)
Definition: logging.h:84
static int mutt_inline_forward(struct Mailbox *m, struct Email *e_edit, struct Email *e_cur, FILE *out)
Forward attachments, inline.
Definition: send.c:590
List of Emails.
Definition: email.h:114
#define STAILQ_FIRST(head)
Definition: queue.h:347
#define WithCrypto
Definition: ncrypt.h:160
QuadOption
Possible values for a quad-option.
Definition: quad.h:36
+ 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 1214 of file send.c.

1215 {
1216  /* Only generate the Mail-Followup-To if the user has requested it, and
1217  * it hasn't already been set */
1218 
1219  if (!C_FollowupTo)
1220  return;
1221 #ifdef USE_NNTP
1222  if (OptNewsSend)
1223  {
1224  if (!env->followup_to && env->newsgroups && (strrchr(env->newsgroups, ',')))
1225  env->followup_to = mutt_str_strdup(env->newsgroups);
1226  return;
1227  }
1228 #endif
1229 
1230  if (TAILQ_EMPTY(&env->mail_followup_to))
1231  {
1232  if (mutt_is_list_recipient(false, env))
1233  {
1234  /* this message goes to known mailing lists, so create a proper
1235  * mail-followup-to header */
1236 
1237  mutt_addrlist_copy(&env->mail_followup_to, &env->to, false);
1238  mutt_addrlist_copy(&env->mail_followup_to, &env->cc, true);
1239  }
1240 
1241  /* remove ourselves from the mail-followup-to header */
1242  remove_user(&env->mail_followup_to, false);
1243 
1244  /* If we are not subscribed to any of the lists in question, re-add
1245  * ourselves to the mail-followup-to header. The mail-followup-to header
1246  * generated is a no-op with group-reply, but makes sure list-reply has the
1247  * desired effect. */
1248 
1249  if (!TAILQ_EMPTY(&env->mail_followup_to) &&
1250  !mutt_is_subscribed_list_recipient(false, env))
1251  {
1252  struct AddressList *al = NULL;
1253  if (!TAILQ_EMPTY(&env->reply_to))
1254  al = &env->reply_to;
1255  else if (!TAILQ_EMPTY(&env->from))
1256  al = &env->from;
1257 
1258  if (al)
1259  {
1260  struct Address *a = NULL;
1261  TAILQ_FOREACH_REVERSE(a, al, AddressList, entries)
1262  {
1264  }
1265  }
1266  else
1267  {
1269  }
1270  }
1271 
1273  }
1274 }
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:728
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:109
struct Address * mutt_addr_copy(const struct Address *addr)
Copy the real address.
Definition: address.c:707
void mutt_addrlist_dedupe(struct AddressList *al)
Remove duplicate addresses.
Definition: address.c:1319
#define TAILQ_FOREACH_REVERSE(var, head, headname, field)
Definition: queue.h:738
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:1334
void mutt_addrlist_prepend(struct AddressList *al, struct Address *a)
Prepend an Address to an AddressList.
Definition: address.c:1413
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:1774
struct AddressList to
Email&#39;s &#39;To&#39; list.
Definition: envelope.h:58
#define TAILQ_EMPTY(head)
Definition: queue.h:714
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:162
int mutt_is_list_recipient(bool all_addr, struct Envelope *e)
Matches known mailing lists.
Definition: pattern.c:1786
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ set_reverse_name()

static void set_reverse_name ( struct AddressList *  al,
struct Envelope env 
)
static

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

Parameters
alAddressList to prepend the found address
envEnvelope to use

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 1285 of file send.c.

1286 {
1287  struct Address *a = NULL;
1288  if (TAILQ_EMPTY(al))
1289  {
1290  TAILQ_FOREACH(a, &env->to, entries)
1291  {
1292  if (mutt_addr_is_user(a))
1293  {
1295  break;
1296  }
1297  }
1298  }
1299 
1300  if (TAILQ_EMPTY(al))
1301  {
1302  TAILQ_FOREACH(a, &env->cc, entries)
1303  {
1304  if (mutt_addr_is_user(a))
1305  {
1307  break;
1308  }
1309  }
1310  }
1311 
1312  if (TAILQ_EMPTY(al))
1313  {
1314  struct Address *from = TAILQ_FIRST(&env->from);
1315  if (from && mutt_addr_is_user(from))
1316  {
1318  }
1319  }
1320 
1321  if (!TAILQ_EMPTY(al))
1322  {
1323  /* when $reverse_realname is not set, clear the personal name so that it
1324  * may be set via a reply- or send-hook. */
1325  if (!C_ReverseRealname)
1326  FREE(&TAILQ_FIRST(al)->personal);
1327  }
1328 }
#define TAILQ_FIRST(head)
Definition: queue.h:716
#define TAILQ_FOREACH(var, head, field)
Definition: queue.h:718
An email address.
Definition: address.h:34
struct Address * mutt_addr_copy(const struct Address *addr)
Copy the real address.
Definition: address.c:707
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
bool C_ReverseRealname
Config: Set the &#39;From&#39; from the full &#39;To&#39; address the email was sent to.
Definition: send.c:130
char * personal
Real name of address.
Definition: address.h:36
#define FREE(x)
Definition: memory.h:40
bool mutt_addr_is_user(const struct Address *addr)
Does the address belong to the user.
Definition: alias.c:682
struct AddressList to
Email&#39;s &#39;To&#39; list.
Definition: envelope.h:58
#define TAILQ_EMPTY(head)
Definition: queue.h:714
void mutt_addrlist_append(struct AddressList *al, struct Address *a)
Append an Address to an AddressList.
Definition: address.c:1402
+ 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 1334 of file send.c.

1335 {
1336  /* Note: We let $from override $realname here.
1337  * Is this the right thing to do?
1338  */
1339 
1340  if (C_From)
1341  {
1342  return mutt_addr_copy(C_From);
1343  }
1344  else if (C_UseDomain)
1345  {
1346  struct Address *addr = mutt_addr_new();
1347  mutt_str_asprintf(&addr->mailbox, "%s@%s", NONULL(Username), NONULL(mutt_fqdn(true)));
1348  return addr;
1349  }
1350  else
1351  {
1352  return mutt_addr_create(NULL, Username);
1353  }
1354 }
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:385
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:707
struct Address * mutt_addr_create(const char *personal, const char *mailbox)
Create and populate a new Address.
Definition: address.c:398
WHERE bool C_UseDomain
Config: Qualify local addresses using this domain.
Definition: globals.h:259
WHERE struct Address * C_From
Config: Default &#39;From&#39; address to use, if isn&#39;t otherwise set.
Definition: globals.h:94
const char * mutt_fqdn(bool may_hide_host)
Get the Fully-Qualified Domain Name.
Definition: sendlib.c:2531
int mutt_str_asprintf(char **strp, const char *fmt,...)
Definition: string.c:1194
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ send_message()

static int send_message ( struct Email e)
static

Send an email.

Parameters
eEmail
Return values
0Success
-1Failure

Definition at line 1362 of file send.c.

1363 {
1364  struct Buffer *tempfile = NULL;
1365  int rc = -1;
1366 #ifdef USE_SMTP
1367  short old_write_bcc;
1368 #endif
1369 
1370  /* Write out the message in MIME form. */
1371  tempfile = mutt_buffer_pool_get();
1372  mutt_buffer_mktemp(tempfile);
1373  FILE *fp_tmp = mutt_file_fopen(mutt_b2s(tempfile), "w");
1374  if (!fp_tmp)
1375  goto cleanup;
1376 
1377 #ifdef USE_SMTP
1378  old_write_bcc = C_WriteBcc;
1379  if (C_SmtpUrl)
1380  C_WriteBcc = false;
1381 #endif
1382 #ifdef MIXMASTER
1384  !STAILQ_EMPTY(&e->chain),
1386 #endif
1387 #ifndef MIXMASTER
1390 #endif
1391 #ifdef USE_SMTP
1392  if (old_write_bcc)
1393  C_WriteBcc = true;
1394 #endif
1395 
1396  fputc('\n', fp_tmp); /* tie off the header. */
1397 
1398  if ((mutt_write_mime_body(e->content, fp_tmp) == -1))
1399  goto cleanup;
1400 
1401  if (mutt_file_fclose(&fp_tmp) != 0)
1402  {
1403  mutt_perror(mutt_b2s(tempfile));
1404  unlink(mutt_b2s(tempfile));
1405  goto cleanup;
1406  }
1407 
1408 #ifdef MIXMASTER
1409  if (!STAILQ_EMPTY(&e->chain))
1410  {
1411  rc = mix_send_message(&e->chain, mutt_b2s(tempfile));
1412  goto cleanup;
1413  }
1414 #endif
1415 
1416 #ifdef USE_NNTP
1417  if (OptNewsSend)
1418  goto sendmail;
1419 #endif
1420 
1421 #ifdef USE_SMTP
1422  if (C_SmtpUrl)
1423  {
1424  rc = mutt_smtp_send(&e->env->from, &e->env->to, &e->env->cc, &e->env->bcc,
1425  mutt_b2s(tempfile), (e->content->encoding == ENC_8BIT));
1426  goto cleanup;
1427  }
1428 #endif
1429 
1430 sendmail:
1431  rc = mutt_invoke_sendmail(&e->env->from, &e->env->to, &e->env->cc, &e->env->bcc,
1432  mutt_b2s(tempfile), (e->content->encoding == ENC_8BIT));
1433 cleanup:
1434  if (fp_tmp)
1435  {
1436  mutt_file_fclose(&fp_tmp);
1437  unlink(mutt_b2s(tempfile));
1438  }
1439  mutt_buffer_pool_release(&tempfile);
1440  return rc;
1441 }
WHERE char * C_SmtpUrl
Config: (smtp) Url of the SMTP server.
Definition: globals.h:142
#define mutt_buffer_mktemp(buf)
Definition: muttlib.h:78
WHERE bool C_WriteBcc
Config: Write out the &#39;Bcc&#39; field when preparing to send a mail.
Definition: globals.h:262
struct Buffer * mutt_buffer_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:101
#define mutt_perror(...)
Definition: logging.h:85
struct AddressList bcc
Email&#39;s &#39;Bcc&#39; list.
Definition: envelope.h:60
A normal Email, write full header + MIME headers.
Definition: sendlib.h:60
bool mutt_should_hide_protected_subject(struct Email *e)
Should NeoMutt hide the protected subject?
Definition: crypt.c:1080
void mutt_buffer_pool_release(struct Buffer **pbuf)
Free a Buffer from the pool.
Definition: pool.c:112
struct Body * content
List of MIME parts.
Definition: email.h:90
String manipulation buffer.
Definition: buffer.h:33
8-bit text
Definition: mime.h:50
int mutt_rfc822_write_header(FILE *fp, struct Envelope *env, struct Body *attach, enum MuttWriteHeaderMode mode, bool privacy, bool hide_protected_subject)
Write out one RFC822 header line.
Definition: sendlib.c:2325
int mutt_invoke_sendmail(struct AddressList *from, struct AddressList *to, struct AddressList *cc, struct AddressList *bcc, const char *msg, int eightbit)
Run sendmail.
Definition: sendlib.c:2823
struct AddressList from
Email&#39;s &#39;From&#39; list.
Definition: envelope.h:57
int mutt_file_fclose(FILE **fp)
Close a FILE handle (and NULL the pointer)
Definition: file.c:152
struct Envelope * env
Envelope information.
Definition: email.h:89
struct AddressList cc
Email&#39;s &#39;Cc&#39; list.
Definition: envelope.h:59
unsigned int encoding
content-transfer-encoding
Definition: body.h:66
#define mutt_b2s(buf)
Definition: buffer.h:41
int mutt_write_mime_body(struct Body *a, FILE *fp)
Write a MIME part.
Definition: sendlib.c:555
int mix_send_message(struct ListHead *chain, const char *tempfile)
Send an email via Mixmaster.
Definition: remailer.c:900
#define STAILQ_EMPTY(head)
Definition: queue.h:345
struct AddressList to
Email&#39;s &#39;To&#39; list.
Definition: envelope.h:58
int mutt_smtp_send(const struct AddressList *from, const struct AddressList *to, const struct AddressList *cc, const struct AddressList *bcc, const char *msgfile, bool eightbit)
Send a message using SMTP.
Definition: smtp.c:738
WHERE bool OptNewsSend
(pseudo) used to change behavior when posting
Definition: options.h:44
FILE * mutt_file_fopen(const char *path, const char *mode)
Call fopen() safely.
Definition: file.c:585
+ 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 1448 of file send.c.

1449 {
1450  for (struct Body *t = b; t; t = t->next)
1451  {
1452  if (t->description)
1453  {
1454  rfc2047_encode(&t->description, NULL, sizeof("Content-Description:"), C_SendCharset);
1455  }
1456  if (recurse && t->parts)
1457  mutt_encode_descriptions(t->parts, recurse);
1458  }
1459 }
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:1448
void rfc2047_encode(char **pd, const char *specials, int col, const char *charsets)
RFC-2047-encode a string.
Definition: rfc2047.c:627
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ decode_descriptions()

static void decode_descriptions ( struct Body b)
static

rfc2047 decode them in case of an error

Parameters
bMIME parts to decode

Definition at line 1465 of file send.c.

1466 {
1467  for (struct Body *t = b; t; t = t->next)
1468  {
1469  if (t->description)
1470  {
1471  rfc2047_decode(&t->description);
1472  }
1473  if (t->parts)
1474  decode_descriptions(t->parts);
1475  }
1476 }
struct Body * next
next attachment in the list
Definition: body.h:53
The body of an email.
Definition: body.h:34
void rfc2047_decode(char **pd)
Decode any RFC2047-encoded header fields.
Definition: rfc2047.c:651
static void decode_descriptions(struct Body *b)
rfc2047 decode them in case of an error
Definition: send.c:1465
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ fix_end_of_file()

static void fix_end_of_file ( const char *  data)
static

Ensure a file ends with a linefeed.

Parameters
dataName of file to fix

Definition at line 1482 of file send.c.

1483 {
1484  FILE *fp = mutt_file_fopen(data, "a+");
1485  if (!fp)
1486  return;
1487  if (fseek(fp, -1, SEEK_END) >= 0)
1488  {
1489  int c = fgetc(fp);
1490  if (c != '\n')
1491  fputc('\n', fp);
1492  }
1493  mutt_file_fclose(&fp);
1494 }
int mutt_file_fclose(FILE **fp)
Close a FILE handle (and NULL the pointer)
Definition: file.c:152
char * data
Pointer to data.
Definition: buffer.h:35
FILE * mutt_file_fopen(const char *path, const char *mode)
Call fopen() safely.
Definition: file.c:585
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_resend_message()

int mutt_resend_message ( FILE *  fp,
struct 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 1505 of file send.c.

1506 {
1507  struct Email *e_new = email_new();
1508 
1509  if (mutt_prepare_template(fp, ctx->mailbox, e_new, e_cur, true) < 0)
1510  {
1511  email_free(&e_new);
1512  return -1;
1513  }
1514 
1515  if (WithCrypto)
1516  {
1517  /* mutt_prepare_template doesn't always flip on an application bit.
1518  * so fix that here */
1519  if (!(e_new->security & (APPLICATION_SMIME | APPLICATION_PGP)))
1520  {
1521  if (((WithCrypto & APPLICATION_SMIME) != 0) && C_SmimeIsDefault)
1522  e_new->security |= APPLICATION_SMIME;
1523  else if (WithCrypto & APPLICATION_PGP)
1524  e_new->security |= APPLICATION_PGP;
1525  else
1526  e_new->security |= APPLICATION_SMIME;
1527  }
1528 
1530  {
1531  e_new->security |= SEC_OPPENCRYPT;
1533  }
1534  }
1535 
1536  struct EmailList el = STAILQ_HEAD_INITIALIZER(el);
1537  emaillist_add_email(&el, e_cur);
1538  int rc = ci_send_message(SEND_RESEND, e_new, NULL, ctx, &el);
1539  emaillist_clear(&el);
1540 
1541  return rc;
1542 }
The envelope/body of an email.
Definition: email.h:37
int emaillist_add_email(struct EmailList *el, struct Email *e)
Add an Email to a list.
Definition: email.c:144
WHERE bool C_SmimeIsDefault
Config: Use SMIME rather than PGP by default.
Definition: globals.h:273
struct Mailbox * mailbox
Definition: context.h:50
#define SEND_RESEND
Reply using the current email as a template.
Definition: send.h:96
WHERE bool C_CryptOpportunisticEncrypt
Config: Enable encryption when the recipient&#39;s key is available.
Definition: globals.h:269
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:1880
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:39
#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:1028
void emaillist_clear(struct EmailList *el)
Drop a private list of Emails.
Definition: email.c:123
#define STAILQ_HEAD_INITIALIZER(head)
Definition: queue.h:321
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:632
#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:

◆ is_reply()

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

Is one email a reply to another?

Parameters
replyEmail to test
origOriginal email
Return values
trueIt is a reply
falseIt is not a reply

Definition at line 1551 of file send.c.

1552 {
1553  if (!reply || !reply->env || !orig || !orig->env)
1554  return false;
1555  return mutt_list_find(&orig->env->references, reply->env->message_id) ||
1556  mutt_list_find(&orig->env->in_reply_to, reply->env->message_id);
1557 }
struct ListHead in_reply_to
in-reply-to header content
Definition: envelope.h:82
char * message_id
Message ID.
Definition: envelope.h:69
struct Envelope * env
Envelope information.
Definition: email.h:89
struct ListNode * mutt_list_find(const struct ListHead *h, const char *data)
Find a string in a List.
Definition: list.c:103
struct ListHead references
message references (in reverse order)
Definition: envelope.h:81
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ search_attach_keyword()

static bool search_attach_keyword ( char *  filename)
static

Search an email for 'attachment' keywords.

Parameters
filenameFilename
Return values
trueIf 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 1569 of file send.c.

1570 {
1571  /* Search for the regex in C_AbortNoattachRegex within a file */
1573  !C_QuoteRegex->regex)
1574  {
1575  return false;
1576  }
1577 
1578  FILE *fp_att = mutt_file_fopen(filename, "r");
1579  if (!fp_att)
1580  return false;
1581 
1582  char *inputline = mutt_mem_malloc(1024);
1583  bool found = false;
1584  while (!feof(fp_att))
1585  {
1586  fgets(inputline, 1024, fp_att);
1587  if (!mutt_is_quote_line(inputline, NULL) &&
1589  {
1590  found = true;
1591  break;
1592  }
1593  }
1594  FREE(&inputline);
1595  mutt_file_fclose(&fp_att);
1596  return found;
1597 }
struct Regex * C_AbortNoattachRegex
Config: Regex to match text indicating attachments are expected.
Definition: send.c:91
regex_t * regex
compiled expression
Definition: regex3.h:60
int mutt_file_fclose(FILE **fp)
Close a FILE handle (and NULL the pointer)
Definition: file.c:152
void * mutt_mem_malloc(size_t size)
Allocate memory on the heap.
Definition: memory.c:90
WHERE struct Regex * C_QuoteRegex
Config: Regex to match quoted text in a reply.
Definition: globals.h:174
bool mutt_regex_match(const struct Regex *regex, const char *str)
Shorthand to mutt_regex_capture()
Definition: regex.c:610
#define FREE(x)
Definition: memory.h:40
int mutt_is_quote_line(char *line, regmatch_t *pmatch)
Is a line of message text a quote?
Definition: pager.c:937
FILE * mutt_file_fopen(const char *path, const char *mode)
Call fopen() safely.
Definition: file.c:585
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ save_fcc()

static int save_fcc ( struct Email e,
struct Buffer fcc,
struct Body clear_content,
char *  pgpkeylist,
SendFlags  flags,
char **  finalpath 
)
static

Save an Email to a 'sent mail' folder.

Parameters
[in]eEmail to save
[in]fccFolder to save to (can be comma-separated list)
[in]clear_contentCleartext content of Email
[in]pgpkeylistList of pgp keys
[in]flagsSend mode, see SendFlags
[out]finalpathPath of final folder
Return values
0Success
-1Error

Definition at line 1610 of file send.c.

1612 {
1613  int rc = 0;
1614  struct Body *save_content = NULL;
1615 
1617 
1618  /* Don't save a copy when we are in batch-mode, and the FCC
1619  * folder is on an IMAP server: This would involve possibly lots
1620  * of user interaction, which is not available in batch mode.
1621  *
1622  * Note: A patch to fix the problems with the use of IMAP servers
1623  * from non-curses mode is available from Brendan Cully. However,
1624  * I'd like to think a bit more about this before including it. */
1625 
1626 #ifdef USE_IMAP
1627  if ((flags & SEND_BATCH) && !mutt_buffer_is_empty(fcc) &&
1628  (imap_path_probe(mutt_b2s(fcc), NULL) == MUTT_IMAP))
1629  {
1630  mutt_buffer_reset(fcc);
1631  mutt_error(_("Fcc to an IMAP mailbox is not supported in batch mode"));
1632  return rc;
1633  }
1634 #endif
1635 
1636  if (mutt_buffer_is_empty(fcc) || (mutt_str_strcmp("/dev/null", mutt_b2s(fcc)) == 0))
1637  return rc;
1638 
1639  struct Body *tmpbody = e->content;
1640  struct Body *save_sig = NULL;
1641  struct Body *save_parts = NULL;
1642 
1643  /* Before sending, we don't allow message manipulation because it
1644  * will break message signatures. This is especially complicated by
1645  * Protected Headers. */
1646  if (!C_FccBeforeSend)
1647  {
1648  if ((WithCrypto != 0) && (e->security & (SEC_ENCRYPT | SEC_SIGN | SEC_AUTOCRYPT)) && C_FccClear)
1649  {
1650  e->content = clear_content;
1653  }
1654 
1655  /* check to see if the user wants copies of all attachments */
1656  if (e->content->type == TYPE_MULTIPART)
1657  {
1658  if ((WithCrypto != 0) && (e->security & (SEC_ENCRYPT | SEC_SIGN | SEC_AUTOCRYPT)) &&
1659  ((mutt_str_strcmp(e->content->subtype, "encrypted") == 0) ||
1660  (mutt_str_strcmp(e->content->subtype, "signed") == 0)))
1661  {
1662  if ((clear_content->type == TYPE_MULTIPART) &&
1663  (query_quadoption(C_FccAttach, _("Save attachments in Fcc?")) == MUTT_NO))
1664  {
1665  if (!(e->security & SEC_ENCRYPT) && (e->security & SEC_SIGN))
1666  {
1667  /* save initial signature and attachments */
1668  save_sig = e->content->parts->next;
1669  save_parts = clear_content->parts->next;
1670  }
1671 
1672  /* this means writing only the main part */
1673  e->content = clear_content->parts;
1674 
1675  if (mutt_protect(e, pgpkeylist, false) == -1)
1676  {
1677  /* we can't do much about it at this point, so
1678  * fallback to saving the whole thing to fcc */
1679  e->content = tmpbody;
1680  save_sig = NULL;
1681  goto full_fcc;
1682  }
1683 
1684  save_content = e->content;
1685  }
1686  }
1687  else
1688  {
1689  if (query_quadoption(C_FccAttach, _("Save attachments in Fcc?")) == MUTT_NO)
1690  e->content = e->content->parts;
1691  }
1692  }
1693  }
1694 
1695 full_fcc:
1696  if (e->content)
1697  {
1698  /* update received time so that when storing to a mbox-style folder
1699  * the From_ line contains the current time instead of when the
1700  * message was first postponed. */
1701  e->received = mutt_date_epoch();
1702  rc = mutt_write_multiple_fcc(mutt_b2s(fcc), e, NULL, false, NULL, finalpath);
1703  while (rc && !(flags & SEND_BATCH))
1704  {
1705  mutt_clear_error();
1706  int choice = mutt_multi_choice(
1707  /* L10N: Called when saving to $record or Fcc failed after sending.
1708  (r)etry tries the same mailbox again.
1709  alternate (m)ailbox prompts for a different mailbox to try.
1710  (s)kip aborts saving. */
1711  _("Fcc failed. (r)etry, alternate (m)ailbox, or (s)kip?"),
1712  /* L10N: These correspond to the "Fcc failed" multi-choice prompt
1713  (r)etry, alternate (m)ailbox, or (s)kip.
1714  Any similarity to famous leaders of the FSF is coincidental. */
1715  _("rms"));
1716  switch (choice)
1717  {
1718  case 2: /* alternate (m)ailbox */
1719  /* L10N: This is the prompt to enter an "alternate (m)ailbox" when the
1720  initial Fcc fails. */
1721  rc = mutt_buffer_enter_fname(_("Fcc mailbox"), fcc, true);
1722  if ((rc == -1) || mutt_buffer_is_empty(fcc))
1723  {
1724  rc = 0;
1725  break;
1726  }
1727  /* fall through */
1728 
1729  case 1: /* (r)etry */
1730  rc = mutt_write_multiple_fcc(mutt_b2s(fcc), e, NULL, false, NULL, finalpath);
1731  break;
1732 
1733  case -1: /* abort */
1734  case 3: /* (s)kip */
1735  rc = 0;
1736  break;
1737  }
1738  }
1739  }
1740 
1741  if (!C_FccBeforeSend)
1742  {
1743  e->content = tmpbody;
1744 
1745  if ((WithCrypto != 0) && save_sig)
1746  {
1747  /* cleanup the second signature structures */
1748  if (save_content->parts)
1749  {
1750  mutt_body_free(&save_content->parts->next);
1751  save_content->parts = NULL;
1752  }
1753  mutt_body_free(&save_content);
1754 
1755  /* restore old signature and attachments */
1756  e->content->parts->next = save_sig;
1757  e->content->parts->parts->next = save_parts;
1758  }
1759  else if ((WithCrypto != 0) && save_content)
1760  {
1761  /* destroy the new encrypted body. */
1762  mutt_body_free(&save_content);
1763  }
1764  }
1765 
1766  return 0;
1767 }
time_t mutt_date_epoch(void)
Return the number of seconds since the Unix epoch.
Definition: date.c:411
#define SEC_AUTOCRYPT
Message will be, or was Autocrypt encrypt+signed.
Definition: ncrypt.h:131
struct Envelope * mime_headers
Memory hole protected headers.
Definition: body.h:63
void mutt_buffer_reset(struct Buffer *buf)
Reset an existing Buffer.
Definition: buffer.c:79
enum MailboxType imap_path_probe(const char *path, const struct stat *st)
Is this an IMAP Mailbox? - Implements MxOps::path_probe()
Definition: imap.c:2474
enum QuadOption query_quadoption(enum QuadOption opt, const char *prompt)
Ask the user a quad-question.
Definition: init.c:3360
bool C_FccBeforeSend
Config: Save FCCs before sending the message.
Definition: send.c:107
struct Body * content
List of MIME parts.
Definition: email.h:90
#define _(a)
Definition: message.h:28
struct Body * next
next attachment in the list
Definition: body.h:53
#define SEC_ENCRYPT
Email is encrypted.
Definition: ncrypt.h:122
The body of an email.
Definition: body.h:34
void mutt_clear_error(void)
Clear the message line (bottom line of screen)
Definition: mutt_logging.c:113
int mutt_write_multiple_fcc(const char *path, struct Email *e, const char *msgid, bool post, char *fcc, char **finalpath)
Handle FCC with multiple, comma separated entries.
Definition: sendlib.c:3205
char * subtype
content-type subtype
Definition: body.h:37
#define mutt_b2s(buf)
Definition: buffer.h:41
int mutt_multi_choice(const char *prompt, const char *letters)
Offer the user a multiple choice question.
Definition: curs_lib.c:933
#define SEC_SIGN
Email is signed.
Definition: ncrypt.h:123
unsigned char C_FccAttach
Config: Save send message with all their attachments.
Definition: send.c:106
User answered &#39;No&#39;, or assume &#39;No&#39;.
Definition: quad.h:39
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:170
struct Body * parts
parts of a multipart or message/rfc822
Definition: body.h:54
bool C_FccClear
Config: Save sent messages unencrypted and unsigned.
Definition: send.c:108
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:39
unsigned int type
content-type primary type
Definition: body.h:65
Type: &#39;multipart/*&#39;.
Definition: mime.h:37
void mutt_buffer_expand_path(struct Buffer *buf)
Create the canonical path.
Definition: muttlib.c:342
#define mutt_error(...)
Definition: logging.h:84
void mutt_body_free(struct Body **ptr)
Free a Body.
Definition: body.c:57
bool mutt_buffer_is_empty(const struct Buffer *buf)
Is the Buffer empty?
Definition: buffer.c:252
&#39;IMAP&#39; Mailbox type
Definition: mailbox.h:52
#define WithCrypto
Definition: ncrypt.h:160
int mutt_str_strcmp(const char *a, const char *b)
Compare two strings, safely.
Definition: string.c:615
#define mutt_buffer_enter_fname(prompt, fname, mailbox)
Definition: curs_lib.h:88
time_t received
Time when the message was placed in the mailbox.
Definition: email.h:82
#define SEND_BATCH
Send email in batch mode (without user interaction)
Definition: send.h:93
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ postpone_message()

static int postpone_message ( struct Email e_post,
struct Email e_cur,
const char *  fcc,
SendFlags  flags 
)
static

Save an Email for another day.

Parameters
e_postEmail to postpone
e_curCurrent Email in the index
fccFolder for 'sent mail'
flagsSend mode, see SendFlags
Return values
0Success
-1Error

Definition at line 1778 of file send.c.

1780 {
1781  char *pgpkeylist = NULL;
1782  char *encrypt_as = NULL;
1783  struct Body *clear_content = NULL;
1784 
1785  if (!C_Postponed)
1786  {
1787  mutt_error(_("Can't postpone. $postponed is unset"));
1788  return -1;
1789  }
1790 
1791  if (e_post->content->next)
1792  e_post->content = mutt_make_multipart(e_post->content);
1793 
1794  mutt_encode_descriptions(e_post->content, true);
1795 
1796  if ((WithCrypto != 0) && C_PostponeEncrypt &&
1797  (e_post->security & (SEC_ENCRYPT | SEC_AUTOCRYPT)))
1798  {
1799  if (((WithCrypto & APPLICATION_PGP) != 0) && (e_post->security & APPLICATION_PGP))
1800  encrypt_as = C_PgpDefaultKey;
1801  else if (((WithCrypto & APPLICATION_SMIME) != 0) && (e_post->security & APPLICATION_SMIME))
1802  encrypt_as = C_SmimeDefaultKey;
1803  if (!encrypt_as)
1804  encrypt_as = C_PostponeEncryptAs;
1805 
1806 #ifdef USE_AUTOCRYPT
1807  if (e_post->security & SEC_AUTOCRYPT)
1808  {
1810  {
1811  e_post->content = mutt_remove_multipart(e_post->content);
1812  decode_descriptions(e_post->content);
1813  return -1;
1814  }
1815  encrypt_as = AutocryptDefaultKey;
1816  }
1817 #endif
1818 
1819  if (encrypt_as)
1820  {
1821  pgpkeylist = mutt_str_strdup(encrypt_as);
1822  clear_content = e_post->content;
1823  if (mutt_protect(e_post, pgpkeylist, true) == -1)
1824  {
1825  FREE(&pgpkeylist);
1826  e_post->content = mutt_remove_multipart(e_post->content);
1827  decode_descriptions(e_post->content);
1828  return -1;
1829  }
1830 
1831  FREE(&pgpkeylist);
1832 
1833  mutt_encode_descriptions(e_post->content, false);
1834  }
1835  }
1836 
1837  /* make sure the message is written to the right part of a maildir
1838  * postponed folder. */
1839  e_post->read = false;
1840  e_post->old = false;
1841 
1842  mutt_prepare_envelope(e_post->env, false);
1843  mutt_env_to_intl(e_post->env, NULL, NULL); /* Handle bad IDNAs the next time. */
1844 
1845  if (mutt_write_fcc(NONULL(C_Postponed), e_post,
1846  (e_cur && (flags & SEND_REPLY)) ? e_cur->env->message_id : NULL,
1847  true, fcc, NULL) < 0)
1848  {
1849  if (clear_content)
1850  {
1851  mutt_body_free(&e_post->content);
1852  e_post->content = clear_content;
1853  }
1854  mutt_env_free(&e_post->content->mime_headers); /* protected headers */
1855  e_post->content = mutt_remove_multipart(e_post->content);
1856  decode_descriptions(e_post->content);
1857  mutt_unprepare_envelope(e_post->env);
1858  return -1;
1859  }
1860 
1862 
1863  if (clear_content)
1864  mutt_body_free(&clear_content);
1865 
1866  return 0;
1867 }
char * C_PostponeEncryptAs
Config: Fallback encryption key for postponed messages.
Definition: send.c:124
#define NONULL(x)
Definition: string2.h:37
#define SEC_AUTOCRYPT
Message will be, or was Autocrypt encrypt+signed.
Definition: ncrypt.h:131
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:1772
WHERE char * C_SmimeDefaultKey
Config: Default key for SMIME operations.
Definition: globals.h:163
WHERE char * AutocryptDefaultKey
Autocrypt default key id (used for postponing messages)
Definition: globals.h:88
struct Body * content
List of MIME parts.
Definition: email.h:90
bool C_PostponeEncrypt
Config: Self-encrypt postponed messages.
Definition: send.c:123
#define _(a)
Definition: message.h:28
struct Body * next
next attachment in the list
Definition: body.h:53
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:309
#define SEC_ENCRYPT
Email is encrypted.
Definition: ncrypt.h:122
int mutt_write_fcc(const char *path, struct Email *e, const char *msgid, bool post, const char *fcc, char **finalpath)
Write email to FCC mailbox.
Definition: sendlib.c:3252
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:3001
bool read
Email is read.
Definition: email.h:51
char * message_id
Message ID.
Definition: envelope.h:69
bool old
Email is seen, but unread.
Definition: email.h:50
struct Envelope * env
Envelope information.
Definition: email.h:89
static void decode_descriptions(struct Body *b)
rfc2047 decode them in case of an error
Definition: send.c:1465
struct Body * mutt_make_multipart(struct Body *b)
Create a multipart email.
Definition: sendlib.c:1746
int mutt_autocrypt_set_sign_as_default_key(struct Email *e)
Set the Autocrypt default key for signing.
Definition: autocrypt.c:674
void mutt_unprepare_envelope(struct Envelope *env)
Undo the encodings of mutt_prepare_envelope()
Definition: sendlib.c:3040
void mutt_encode_descriptions(struct Body *b, bool recurse)
rfc2047 encode the content-descriptions
Definition: send.c:1448
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:170
void mutt_update_num_postponed(void)
Force the update of the number of postponed messages.
Definition: postpone.c:199
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:39
#define SEND_REPLY
Reply to sender.
Definition: send.h:88
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: ncrypt.h:134
char * mutt_str_strdup(const char *str)
Copy a string, safely.
Definition: string.c:380
#define mutt_error(...)
Definition: logging.h:84
WHERE char * C_PgpDefaultKey
Config: Default key to use for PGP operations.
Definition: globals.h:159
#define FREE(x)
Definition: memory.h:40
void mutt_body_free(struct Body **ptr)
Free a Body.
Definition: body.c:57
WHERE char * C_Postponed
Config: Folder to store postponed messages.
Definition: globals.h:134
#define WithCrypto
Definition: ncrypt.h:160
#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:

◆ 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 1880 of file send.c.

1882 {
1883  char buf[1024];
1884  struct Buffer fcc = mutt_buffer_make(0); /* where to copy this message */
1885  FILE *fp_tmp = NULL;
1886  struct Body *pbody = NULL;
1887  int i;
1888  bool free_clear_content = false;
1889 
1890  struct Body *clear_content = NULL;
1891  char *pgpkeylist = NULL;
1892  /* save current value of "pgp_sign_as" and "smime_default_key" */
1893  char *pgp_signas = NULL;
1894  char *smime_signas = NULL;
1895  const char *tag = NULL;
1896  char *err = NULL;
1897  char *ctype = NULL;
1898  char *finalpath = NULL;
1899  struct EmailNode *en = NULL;
1900  struct Email *e_cur = NULL;
1901 
1902  if (el)
1903  en = STAILQ_FIRST(el);
1904  if (en)
1905  e_cur = STAILQ_NEXT(en, entries) ? NULL : en->email;
1906 
1907  int rc = -1;
1908 
1909 #ifdef USE_NNTP
1910  if (flags & SEND_NEWS)
1911  OptNewsSend = true;
1912  else
1913  OptNewsSend = false;
1914 #endif
1915 
1916  if (!flags && !e_templ && (C_Recall != MUTT_NO) &&
1917  mutt_num_postponed(ctx ? ctx->mailbox : NULL, true))
1918  {
1919  /* If the user is composing a new message, check to see if there
1920  * are any postponed messages first. */
1921  enum QuadOption ans =
1922  query_quadoption(C_Recall, _("Recall postponed message?"));
1923  if (ans == MUTT_ABORT)
1924  return rc;
1925 
1926  if (ans == MUTT_YES)
1927  flags |= SEND_POSTPONED;
1928  }
1929 
1930  /* Allocate the buffer due to the long lifetime, but
1931  * pre-resize it to ensure there are no NULL data field issues */
1932  mutt_buffer_alloc(&fcc, 1024);
1933 
1934  if (flags & SEND_POSTPONED)
1935  {
1937  pgp_signas = mutt_str_strdup(C_PgpSignAs);
1939  smime_signas = mutt_str_strdup(C_SmimeSignAs);
1940  }
1941 
1942  /* Delay expansion of aliases until absolutely necessary--shouldn't
1943  * be necessary unless we are prompting the user or about to execute a
1944  * send-hook. */
1945 
1946  if (!e_templ)
1947  {
1948  e_templ = email_new();
1949 
1950  if (flags == SEND_POSTPONED)
1951  {
1952  rc = mutt_get_postponed(ctx, e_templ, &e_cur, &fcc);
1953  if (rc < 0)
1954  {
1955  flags = SEND_POSTPONED;
1956  goto cleanup;
1957  }
1958  flags = rc;
1959 #ifdef USE_NNTP
1960  /* If postponed message is a news article, it have
1961  * a "Newsgroups:" header line, then set appropriate flag. */
1962  if (e_templ->env->newsgroups)
1963  {
1964  flags |= SEND_NEWS;
1965  OptNewsSend = true;
1966  }
1967  else
1968  {
1969  flags &= ~SEND_NEWS;
1970  OptNewsSend = false;
1971  }
1972 #endif
1973  }
1974 
1975  if (flags & (SEND_POSTPONED | SEND_RESEND))
1976  {
1977  fp_tmp = mutt_file_fopen(e_templ->content->filename, "a+");
1978  if (!fp_tmp)
1979  {
1980  mutt_perror(e_templ->content->filename);
1981  goto cleanup;
1982  }
1983  }
1984 
1985  if (!e_templ->env)
1986  e_templ->env = mutt_env_new();
1987  }
1988 
1989  /* Parse and use an eventual list-post header */
1990  if ((flags & SEND_LIST_REPLY) && e_cur && e_cur->env && e_cur->env->list_post)
1991  {
1992  /* Use any list-post header as a template */
1993  mutt_parse_mailto(e_templ->env, NULL, e_cur->env->list_post);
1994  /* We don't let them set the sender's address. */
1995  mutt_addrlist_clear(&e_templ->env->from);
1996  }
1997 
1998  if (!(flags & (SEND_KEY | SEND_POSTPONED | SEND_RESEND)))
1999  {
2000  /* When SEND_DRAFT_FILE is set, the caller has already
2001  * created the "parent" body structure. */
2002  if (!(flags & SEND_DRAFT_FILE))
2003  {
2004  pbody = mutt_body_new();
2005  pbody->next = e_templ->content; /* don't kill command-line attachments */
2006  e_templ->content = pbody;
2007 
2008  ctype = mutt_str_strdup(C_ContentType);
2009  if (!ctype)
2010  ctype = mutt_str_strdup("text/plain");
2011  mutt_parse_content_type(ctype, e_templ->content);
2012  FREE(&ctype);
2013  e_templ->content->unlink = true;
2014  e_templ->content->use_disp = false;
2015  e_templ->content->disposition = DISP_INLINE;
2016 
2017  if (tempfile)
2018  {
2019  fp_tmp = mutt_file_fopen(tempfile, "a+");
2020  e_templ->content->filename = mutt_str_strdup(tempfile);
2021  }
2022  else
2023  {
2024  mutt_mktemp(buf, sizeof(buf));
2025  fp_tmp = mutt_file_fopen(buf, "w+");
2026  e_templ->content->filename = mutt_str_strdup(buf);
2027  }
2028  }
2029  else
2030  fp_tmp = mutt_file_fopen(e_templ->content->filename, "a+");
2031 
2032  if (!fp_tmp)
2033  {
2034  mutt_debug(LL_DEBUG1, "can't create tempfile %s (errno=%d)\n",
2035  e_templ->content->filename, errno);
2036  mutt_perror(e_templ->content->filename);
2037  goto cleanup;
2038  }
2039  }
2040 
2041  /* this is handled here so that the user can match ~f in send-hook */
2042  if (e_cur && C_ReverseName && !(flags & (SEND_POSTPONED | SEND_RESEND)))
2043  {
2044  /* We shouldn't have to worry about alias expansion here since we are
2045  * either replying to a real or postponed message, therefore no aliases
2046  * should exist since the user has not had the opportunity to add
2047  * addresses to the list. We just have to ensure the postponed messages
2048  * have their aliases expanded. */
2049 
2050  if (!TAILQ_EMPTY(&e_templ->env->from))
2051  {
2052  mutt_debug(LL_DEBUG5, "e_templ->env->from before set_reverse_name: %s\n",
2053  TAILQ_FIRST(&e_templ->env->from)->mailbox);
2054  mutt_addrlist_clear(&e_templ->env->from);
2055  }
2056  set_reverse_name(&e_templ->env->from, e_cur->env);
2057  }
2058  if (e_cur && C_ReplyWithXorig && !(flags & (SEND_POSTPONED | SEND_RESEND | SEND_FORWARD)))
2059  {
2060  /* We shouldn't have to worry about freeing 'e_templ->env->from' before
2061  * setting it here since this code will only execute when doing some
2062  * sort of reply. The pointer will only be set when using the -H command
2063  * line option.
2064  *
2065  * If there is already a from address recorded in 'e_templ->env->from',
2066  * then it theoretically comes from C_ReverseName handling, and we don't use
2067  * the 'X-Orig-To header'. */
2068  if (!TAILQ_EMPTY(&e_cur->env->x_original_to) && TAILQ_EMPTY(&e_templ->env->from))
2069  {
2070  mutt_addrlist_copy(&e_templ->env->from, &e_cur->env->x_original_to, false);
2071  mutt_debug(LL_DEBUG5, "e_templ->env->from extracted from X-Original-To: header: %s\n",
2072  TAILQ_FIRST(&e_templ->env->from)->mailbox);
2073  }
2074  }
2075 
2076  if (!(flags & (SEND_POSTPONED | SEND_RESEND)) &&
2077  !((flags & SEND_DRAFT_FILE) && C_ResumeDraftFiles))
2078  {
2079  if ((flags & (SEND_REPLY | SEND_FORWARD | SEND_TO_SENDER)) && ctx &&
2080  (envelope_defaults(e_templ->env, ctx->mailbox, el, flags) == -1))
2081  {
2082  goto cleanup;
2083  }
2084 
2085  if (C_Hdrs)
2086  process_user_recips(e_templ->env);
2087 
2088  /* Expand aliases and remove duplicates/crossrefs */
2089  mutt_expand_aliases_env(e_templ->env);
2090 
2091  if (flags & SEND_REPLY)
2092  mutt_fix_reply_recipients(e_templ->env);
2093 
2094 #ifdef USE_NNTP
2095  if ((flags & SEND_NEWS) && ctx && (ctx->mailbox->magic == MUTT_NNTP) &&
2096  !e_templ->env->newsgroups)
2097  {
2098  e_templ->env->newsgroups =
2099  mutt_str_strdup(((struct NntpMboxData *) ctx->mailbox->mdata)->group);
2100  }
2101 #endif
2102 
2103  if (!(flags & (SEND_MAILX | SEND_BATCH)) &&
2104  !(C_Autoedit && C_EditHeaders) && !((flags & SEND_REPLY) && C_FastReply))
2105  {
2106  if (edit_envelope(e_templ->env, flags) == -1)
2107  goto cleanup;
2108  }
2109 
2110  /* the from address must be set here regardless of whether or not
2111  * $use_from is set so that the '~P' (from you) operator in send-hook
2112  * patterns will work. if $use_from is unset, the from address is killed
2113  * after send-hooks are evaluated */
2114 
2115  const bool killfrom = TAILQ_EMPTY(&e_templ->env->from);
2116  if (killfrom)
2117  {
2119  }
2120 
2121  if ((flags & SEND_REPLY) && e_cur)
2122  {
2123  /* change setting based upon message we are replying to */
2124  mutt_message_hook(ctx ? ctx->mailbox : NULL, e_cur, MUTT_REPLY_HOOK);
2125 
2126  /* set the replied flag for the message we are generating so that the
2127  * user can use ~Q in a send-hook to know when reply-hook's are also
2128  * being used. */
2129  e_templ->replied = true;
2130  }
2131 
2132  /* change settings based upon recipients */
2133 
2134  mutt_message_hook(NULL, e_templ, MUTT_SEND_HOOK);
2135 
2136  /* Unset the replied flag from the message we are composing since it is
2137  * no longer required. This is done here because the FCC'd copy of
2138  * this message was erroneously get the 'R'eplied flag when stored in
2139  * a maildir-style mailbox. */
2140  e_templ->replied = false;
2141 
2142  /* $use_from and/or $from might have changed in a send-hook */
2143  if (killfrom)
2144  {
2145  mutt_addrlist_clear(&e_templ->env->from);
2146  if (C_UseFrom && !(flags & (SEND_POSTPONED | SEND_RESEND)))
2148  }
2149 
2150  if (C_Hdrs)
2151  process_user_header(e_templ->env);
2152 
2153  if (flags & SEND_BATCH)
2154  mutt_file_copy_stream(stdin, fp_tmp);
2155 
2156  if (C_SigOnTop && !(flags & (SEND_MAILX | SEND_KEY | SEND_BATCH)) &&
2157  C_Editor && (mutt_str_strcmp(C_Editor, "builtin") != 0))
2158  {
2159  append_signature(fp_tmp);
2160  }
2161 
2162  /* include replies/forwarded messages, unless we are given a template */
2163  if (!tempfile && (ctx || !(flags & (SEND_REPLY | SEND_FORWARD))) &&
2164  (generate_body(fp_tmp, e_templ, flags, ctx ? ctx->mailbox : NULL, el) == -1))
2165  {
2166  goto cleanup;
2167  }
2168 
2169  if (!C_SigOnTop && !(flags & (SEND_MAILX | SEND_KEY | SEND_BATCH)) &&
2170  C_Editor && (mutt_str_strcmp(C_Editor, "builtin") != 0))
2171  {
2172  append_signature(fp_tmp);
2173  }
2174  }
2175 
2176  /* Only set format=flowed for new messages. postponed/resent/draftfiles
2177  * should respect the original email.
2178  *
2179  * This is set here so that send-hook can be used to turn the option on. */
2180  if (!(flags & (SEND_KEY | SEND_POSTPONED | SEND_RESEND | SEND_DRAFT_FILE)))
2181  {
2182  if (C_TextFlowed && (e_templ->content->type == TYPE_TEXT) &&
2183  (mutt_str_strcasecmp(e_templ->content->subtype, "plain") == 0))
2184  {
2185  mutt_param_set(&e_templ->content->parameter, "format", "flowed");
2186  }
2187  }
2188 
2189  /* This hook is even called for postponed messages, and can, e.g., be
2190  * used for setting the editor, the sendmail path, or the
2191  * envelope sender. */
2192  mutt_message_hook(NULL, e_templ, MUTT_SEND2_HOOK);
2193 
2194  /* wait until now to set the real name portion of our return address so
2195  * that $realname can be set in a send-hook */
2196  {
2197  struct Address *from = TAILQ_FIRST(&e_templ->env->from);
2198  if (from && !from->personal && !(flags & (SEND_RESEND | SEND_POSTPONED)))
2200  }
2201 
2202  if (!(((WithCrypto & APPLICATION_PGP) != 0) && (flags & SEND_KEY)))
2203  mutt_file_fclose(&fp_tmp);
2204 
2205  if (flags & SEND_MAILX)
2206  {
2207  if (mutt_builtin_editor(e_templ->content->filename, e_templ, e_cur) == -1)
2208  goto cleanup;
2209  }
2210  else if (!(flags & SEND_BATCH))
2211  {
2212  struct stat st;
2213  time_t mtime = mutt_file_decrease_mtime(e_templ->content->filename, NULL);
2214 
2215  mutt_update_encoding(e_templ->content);
2216 
2217  /* Select whether or not the user's editor should be called now. We
2218  * don't want to do this when:
2219  * 1) we are sending a key/cert
2220  * 2) we are forwarding a message and the user doesn't want to edit it.
2221  * This is controlled by the quadoption $forward_edit. However, if
2222  * both $edit_headers and $autoedit are set, we want to ignore the
2223  * setting of $forward_edit because the user probably needs to add the
2224  * recipients. */
2225  if (!(flags & SEND_KEY) &&
2226  (((flags & SEND_FORWARD) == 0) || (C_EditHeaders && C_Autoedit) ||
2227  (query_quadoption(C_ForwardEdit, _("Edit forwarded message?")) == MUTT_YES)))
2228  {
2229  /* If the this isn't a text message, look for a mailcap edit command */
2230  if (mutt_needs_mailcap(e_templ->content))
2231  {
2232  if (!mutt_edit_attachment(e_templ->content))
2233  goto cleanup;
2234  }
2235  else if (!C_Editor || (mutt_str_strcmp("builtin", C_Editor) == 0))
2236  mutt_builtin_editor(e_templ->content->filename, e_templ, e_cur);
2237  else if (C_EditHeaders)
2238  {
2239  mutt_env_to_local(e_templ->env);
2240  mutt_edit_headers(C_Editor, e_templ->content->filename, e_templ, &fcc);
2241  mutt_env_to_intl(e_templ->env, NULL, NULL);
2242  }
2243  else
2244  {
2246  if (stat(e_templ->content->filename, &st) == 0)
2247  {
2248  if (mtime != st.st_mtime)
2249  fix_end_of_file(e_templ->content->filename);
2250  }
2251  else
2252  mutt_perror(e_templ->content->filename);
2253  }
2254 
2255  mutt_message_hook(NULL, e_templ, MUTT_SEND2_HOOK);
2256  }
2257 
2258  if (!(flags & (SEND_POSTPONED | SEND_FORWARD | SEND_KEY | SEND_RESEND | SEND_DRAFT_FILE)))
2259  {
2260  if (stat(e_templ->content->filename, &st) == 0)
2261  {
2262  /* if the file was not modified, bail out now */
2263  if ((mtime == st.st_mtime) && !e_templ->content->next &&
2265  _("Abort unmodified message?")) == MUTT_YES))
2266  {
2267  mutt_message(_("Aborted unmodified message"));
2268  goto cleanup;
2269  }
2270  }
2271  else
2272  mutt_perror(e_templ->content->filename);
2273  }
2274  }
2275 
2276  /* Set the message security unless:
2277  * 1) crypto support is not enabled (WithCrypto==0)
2278  * 2) pgp: header field was present during message editing with $edit_headers (e_templ->security != 0)
2279  * 3) we are resending a message
2280  * 4) we are recalling a postponed message (don't override the user's saved settings)
2281  * 5) we are in mailx mode
2282  * 6) we are in batch mode
2283  *
2284  * This is done after allowing the user to edit the message so that security
2285  * settings can be configured with send2-hook and $edit_headers. */
2286  if ((WithCrypto != 0) && (e_templ->security == 0) &&
2287  !(flags & (SEND_BATCH | SEND_MAILX | SEND_POSTPONED | SEND_RESEND)))
2288  {
2289  if (
2290 #ifdef USE_AUTOCRYPT
2292 #else
2293  0
2294 #endif
2295  && e_cur && (e_cur->security & SEC_AUTOCRYPT))
2296  {
2298  }
2299  else
2300  {
2301  if (C_CryptAutosign)
2302  e_templ->security |= SEC_SIGN;
2303  if (C_CryptAutoencrypt)
2304  e_templ->security |= SEC_ENCRYPT;
2305  if (C_CryptReplyencrypt && e_cur && (e_cur->security & SEC_ENCRYPT))
2306  e_templ->security |= SEC_ENCRYPT;
2307  if (C_CryptReplysign && e_cur && (e_cur->security & SEC_SIGN))
2308  e_templ->security |= SEC_SIGN;
2309  if (C_CryptReplysignencrypted && e_cur && (e_cur->security & SEC_ENCRYPT))
2310  e_templ->security |= SEC_SIGN;
2311  if (((WithCrypto & APPLICATION_PGP) != 0) &&
2313  {
2314  if (C_PgpAutoinline)
2315  e_templ->security |= SEC_INLINE;
2316  if (C_PgpReplyinline && e_cur && (e_cur->security & SEC_INLINE))
2317  e_templ->security |= SEC_INLINE;
2318  }
2319  }
2320 
2321  if (e_templ->security || C_CryptOpportunisticEncrypt)
2322  {
2323  /* When replying / forwarding, use the original message's
2324  * crypto system. According to the documentation,
2325  * smime_is_default should be disregarded here.
2326  *
2327  * Problem: At least with forwarding, this doesn't really
2328  * make much sense. Should we have an option to completely
2329  * disable individual mechanisms at run-time? */
2330  if (e_cur)
2331  {
2332  if (((WithCrypto & APPLICATION_PGP) != 0) && C_CryptAutopgp &&
2333  (e_cur->security & APPLICATION_PGP))
2334  {
2335  e_templ->security |= APPLICATION_PGP;
2336  }
2337  else if (((WithCrypto & APPLICATION_SMIME) != 0) && C_CryptAutosmime &&
2338  (e_cur->security & APPLICATION_SMIME))
2339  {
2340  e_templ->security |= APPLICATION_SMIME;
2341  }
2342  }
2343 
2344  /* No crypto mechanism selected? Use availability + smime_is_default
2345  * for the decision. */
2346  if (!(e_templ->security & (APPLICATION_SMIME | APPLICATION_PGP)))
2347  {
2348  if (((WithCrypto & APPLICATION_SMIME) != 0) && C_CryptAutosmime && C_SmimeIsDefault)
2349  {
2350  e_templ->security |= APPLICATION_SMIME;
2351  }
2352  else if (((WithCrypto & APPLICATION_PGP) != 0) && C_CryptAutopgp)
2353  {
2354  e_templ->security |= APPLICATION_PGP;
2355  }
2356  else if (((WithCrypto & APPLICATION_SMIME) != 0) && C_CryptAutosmime)
2357  {
2358  e_templ->security |= APPLICATION_SMIME;
2359  }
2360  }
2361  }
2362 
2363  /* opportunistic encrypt relies on SMIME or PGP already being selected */
2365  {
2366  /* If something has already enabled encryption, e.g. C_CryptAutoencrypt
2367  * or C_CryptReplyencrypt, then don't enable opportunistic encrypt for
2368  * the message. */
2369  if (!(e_templ->security & (SEC_ENCRYPT | SEC_AUTOCRYPT)))
2370  {
2371  e_templ->security |= SEC_OPPENCRYPT;
2372  crypt_opportunistic_encrypt(e_templ);
2373  }
2374  }
2375 
2376  /* No permissible mechanisms found. Don't sign or encrypt. */
2377  if (!(e_templ->security & (APPLICATION_SMIME | APPLICATION_PGP)))
2378  e_templ->security = SEC_NO_FLAGS;
2379  }
2380 
2381  /* Deal with the corner case where the crypto module backend is not available.
2382  * This can happen if configured without pgp/smime and with gpgme, but
2383  * $crypt_use_gpgme is unset. */
2384  if (e_templ->security && !crypt_has_module_backend(e_templ->security))
2385  {
2386  mutt_error(_(
2387  "No crypto backend configured. Disabling message security setting."));
2388  e_templ->security = SEC_NO_FLAGS;
2389  }
2390 
2391  /* specify a default fcc. if we are in batchmode, only save a copy of
2392  * the message if the value of $copy is yes or ask-yes */
2393 
2394  if (mutt_buffer_is_empty(&fcc) && !(flags & SEND_POSTPONED_FCC) &&
2395  (!(flags & SEND_BATCH) || (C_Copy & 0x1)))
2396  {
2397  /* set the default FCC */
2398  const bool killfrom = TAILQ_EMPTY(&e_templ->env->from);
2399  if (killfrom)
2400  {
2402  }
2403  mutt_select_fcc(&fcc, e_templ);
2404  if (killfrom)
2405  {
2406  mutt_addrlist_clear(&e_templ->env->from);
2407  }
2408  }
2409 
2410  mutt_rfc3676_space_stuff(e_templ);
2411 
2412  mutt_update_encoding(e_templ->content);
2413 
2414  if (!(flags & (SEND_MAILX | SEND_BATCH)))
2415  {
2416  main_loop:
2417 
2419  i = mutt_compose_menu(e_templ, &fcc, e_cur,
2421  if (i == -1)
2422  {
2423 /* abort */
2424 #ifdef USE_NNTP
2425  if (flags & SEND_NEWS)
2426  mutt_message(_("Article not posted"));
2427  else
2428 #endif
2429  mutt_message(_("Mail not sent"));
2430  goto cleanup;
2431  }
2432  else if (i == 1)
2433  {
2434  if (postpone_message(e_templ, e_cur, mutt_b2s(&fcc), flags) != 0)
2435  goto main_loop;
2436  mutt_message(_("Message postponed"));
2437  rc = 1;
2438  goto cleanup;
2439  }
2440  }
2441 
2442 #ifdef USE_NNTP
2443  if (!(flags & SEND_NEWS))
2444 #endif
2445  if ((mutt_addrlist_count_recips(&e_templ->env->to) == 0) &&
2446  (mutt_addrlist_count_recips(&e_templ->env->cc) == 0) &&
2447  (mutt_addrlist_count_recips(&e_templ->env->bcc) == 0))
2448  {
2449  if (flags & SEND_BATCH)
2450  {
2451  puts(_("No recipients specified"));
2452  goto cleanup;
2453  }
2454 
2455  mutt_error(_("No recipients specified"));
2456  goto main_loop;
2457  }
2458 
2459  if (mutt_env_to_intl(e_templ->env, &tag, &err))
2460  {
2461  mutt_error(_("Bad IDN in '%s': '%s'"), tag, err);
2462  FREE(&err);
2463  if (flags & SEND_BATCH)
2464  goto cleanup;
2465  goto main_loop;
2466  }
2467 
2468  if (!e_templ->env->subject && !(flags & SEND_BATCH) &&
2469  (query_quadoption(C_AbortNosubject, _("No subject, abort sending?")) != MUTT_NO))
2470  {
2471  /* if the abort is automatic, print an error message */
2472  if (C_AbortNosubject == MUTT_YES)
2473  mutt_error(_("No subject specified"));
2474  goto main_loop;
2475  }
2476 #ifdef USE_NNTP
2477  if ((flags & SEND_NEWS) && !e_templ->env->subject)
2478  {
2479  mutt_error(_("No subject specified"));
2480  goto main_loop;
2481  }
2482 
2483  if ((flags & SEND_NEWS) && !e_templ->env->newsgroups)
2484  {
2485  mutt_error(_("No newsgroup specified"));
2486  goto main_loop;
2487  }
2488 #endif
2489 
2490  if (!(flags & SEND_BATCH) && (C_AbortNoattach != MUTT_NO) &&
2491  !e_templ->content->next && (e_templ->content->type == TYPE_TEXT) &&
2492  (mutt_str_strcasecmp(e_templ->content->subtype, "plain") == 0) &&
2493  search_attach_keyword(e_templ->content->filename) &&
2495  _("No attachments, cancel sending?")) != MUTT_NO))
2496  {
2497  /* if the abort is automatic, print an error message */
2498  if (C_AbortNoattach == MUTT_YES)
2499  {
2500  mutt_error(_("Message contains text matching "
2501  "\"$abort_noattach_regex\". Not sending."));
2502  }
2503  goto main_loop;
2504  }
2505 
2506  if (e_templ->content->next)
2507  e_templ->content = mutt_make_multipart(e_templ->content);
2508 
2509  /* Ok, we need to do it this way instead of handling all fcc stuff in
2510  * one place in order to avoid going to main_loop with encoded "env"
2511  * in case of error. Ugh. */
2512 
2513  mutt_encode_descriptions(e_templ->content, true);
2514 
2515  /* Make sure that clear_content and free_clear_content are
2516  * properly initialized -- we may visit this particular place in
2517  * the code multiple times, including after a failed call to
2518  * mutt_protect(). */
2519 
2520  clear_content = NULL;
2521  free_clear_content = false;
2522 
2523  if (WithCrypto)
2524  {
2525  if (e_templ->security & (SEC_ENCRYPT | SEC_SIGN | SEC_AUTOCRYPT))
2526  {
2527  /* save the decrypted attachments */
2528  clear_content = e_templ->content;
2529 
2530  if ((crypt_get_keys(e_templ, &pgpkeylist, 0) == -1) ||
2531  (mutt_protect(e_templ, pgpkeylist, false) == -1))
2532  {
2533  e_templ->content = mutt_remove_multipart(e_templ->content);
2534 
2535  FREE(&pgpkeylist);
2536 
2537  decode_descriptions(e_templ->content);
2538  goto main_loop;
2539  }
2540  mutt_encode_descriptions(e_templ->content, false);
2541  }
2542 
2543  /* at this point, e_templ->content is one of the following three things:
2544  * - multipart/signed. In this case, clear_content is a child
2545  * - multipart/encrypted. In this case, clear_content exists independently
2546  * - application/pgp. In this case, clear_content exists independently
2547  * - something else. In this case, it's the same as clear_content
2548  */
2549 
2550  /* This is ugly -- lack of "reporting back" from mutt_protect(). */
2551 
2552  if (clear_content && (e_templ->content != clear_content) &&
2553  (e_templ->content->parts != clear_content))
2554  free_clear_content = true;
2555  }
2556 
2557  if (!OptNoCurses && !(flags & SEND_MAILX))
2558  mutt_message(_("Sending message..."));
2559 
2560  mutt_prepare_envelope(e_templ->env, true);
2561 
2562  if (C_FccBeforeSend)
2563  save_fcc(e_templ, &fcc, clear_content, pgpkeylist, flags, &finalpath);
2564 
2565  i = send_message(e_templ);
2566  if (i < 0)
2567  {
2568  if (!(flags & SEND_BATCH))
2569  {
2570  if (!WithCrypto)
2571  ;
2572  else if ((e_templ->security & (SEC_ENCRYPT | SEC_AUTOCRYPT)) ||
2573  ((e_templ->security & SEC_SIGN) && (e_templ->content->type == TYPE_APPLICATION)))
2574  {
2575  if (e_templ->content != clear_content)
2576  {
2577  mutt_body_free(&e_templ->content); /* destroy PGP data */
2578  e_templ->content = clear_content; /* restore clear text. */
2579  }
2580  }
2581  else if ((e_templ->security & SEC_SIGN) && (e_templ->content->type == TYPE_MULTIPART))
2582  {
2583  mutt_body_free(&e_templ->content->parts->next); /* destroy sig */
2584  e_templ->content = mutt_remove_multipart(e_templ->content);
2585  }
2586 
2587  FREE(&pgpkeylist);
2588  mutt_env_free(&e_templ->content->mime_headers); /* protected headers */
2589  e_templ->content = mutt_remove_multipart(e_templ->content);
2590  decode_descriptions(e_templ->content);
2591  mutt_unprepare_envelope(e_templ->env);
2592  FREE(&finalpath);
2593  goto main_loop;
2594  }
2595  else
2596  {
2597  puts(_("Could not send the message"));
2598  goto cleanup;
2599  }
2600  }
2601 
2602  if (!C_FccBeforeSend)
2603  save_fcc(e_templ, &fcc, clear_content, pgpkeylist, flags, &finalpath);
2604 
2605  if (!OptNoCurses && !(flags & SEND_MAILX))
2606  {
2607  mutt_message((i != 0) ? _("Sending in background") :
2608  (flags & SEND_NEWS) ? _("Article posted") : /* USE_NNTP */
2609  _("Mail sent"));
2610 #ifdef USE_NOTMUCH
2611  if (C_NmRecord)
2612  nm_record_message(ctx ? ctx->mailbox : NULL, finalpath, e_cur);
2613 #endif
2614  mutt_sleep(0);
2615  }
2616 
2617  if (WithCrypto)
2618  FREE(&pgpkeylist);
2619 
2620  if ((WithCrypto != 0) && free_clear_content)
2621  mutt_body_free(&clear_content);
2622 
2623  /* set 'replied' flag only if the user didn't change/remove
2624  * In-Reply-To: and References: headers during edit */
2625  if (flags & SEND_REPLY)
2626  {
2627  if (!(flags & SEND_POSTPONED) && ctx && ctx->mailbox)
2628  {
2629  STAILQ_FOREACH(en, el, entries)
2630  {
2631  mutt_set_flag(ctx->mailbox, en->email, MUTT_REPLIED, is_reply(en->email, e_templ));
2632  }
2633  }
2634  }
2635 
2636  rc = 0;
2637 
2638 cleanup:
2639  mutt_buffer_dealloc(&fcc);
2640 
2641  if (flags & SEND_POSTPONED)
2642  {
2643  if (WithCrypto & APPLICATION_PGP)
2644  {
2645  FREE(&C_PgpSignAs);
2646  C_PgpSignAs = pgp_signas;
2647  }
2648  if (WithCrypto & APPLICATION_SMIME)
2649  {
2650  FREE(&C_SmimeSignAs);
2651  C_SmimeSignAs = smime_signas;
2652  }
2653  }
2654 
2655  mutt_file_fclose(&fp_tmp);
2656  if (!(flags & SEND_NO_FREE_HEADER))
2657  email_free(&e_templ);
2658 
2659  FREE(&finalpath);
2660  return rc;
2661 }
#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:912
bool C_Hdrs
Config: Add custom headers to outgoing mail.
Definition: send.c:115
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:198
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:1772
#define mutt_set_flag(m, e, flag, bf)
Definition: protos.h:70
#define SEND_POSTPONED_FCC
Used by mutt_get_postponed() to signal that the x-mutt-fcc header field was present.
Definition: send.h:97
#define SEND_TO_SENDER
Compose new email to sender.
Definition: send.h:100
The envelope/body of an email.
Definition: email.h:37
#define TAILQ_FIRST(head)
Definition: queue.h:716
#define mutt_perror(...)
Definition: logging.h:85
static int postpone_message(struct Email *e_post, struct Email *e_cur, const char *fcc, SendFlags flags)
Save an Email for another day.
Definition: send.c:1778
static void fix_end_of_file(const char *data)
Ensure a file ends with a linefeed.
Definition: send.c:1482
WHERE bool C_AutocryptReply
Config: Replying to an autocrypt email automatically enables autocrypt in the reply.
Definition: globals.h:199
&#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:90
static bool search_attach_keyword(char *filename)
Search an email for &#39;attachment&#39; keywords.
Definition: send.c:1569
User aborted the question (with Ctrl-G)
Definition: quad.h:38
enum QuadOption query_quadoption(enum QuadOption opt, const char *prompt)
Ask the user a quad-question.
Definition: init.c:3360
#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:1595
User answered &#39;Yes&#39;, or assume &#39;Yes&#39;.
Definition: quad.h:40
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:1382
#define SEND_DRAFT_FILE
Used by the -H flag.
Definition: send.h:99
#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:317
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:1032
#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:378
#define SEND_FORWARD
Forward email.
Definition: send.h:91
void mutt_addrlist_copy(struct AddressList *dst, const struct AddressList *src, bool prune)
Copy a list of addresses into another list.
Definition: address.c:728
bool C_FccBeforeSend
Config: Save FCCs before sending the message.
Definition: send.c:107
struct Body * content
List of MIME parts.
Definition: email.h:90
struct Buffer mutt_buffer_make(size_t size)
Make a new buffer on the stack.
Definition: buffer.c:61
int mutt_edit_attachment(struct Body *a)
Edit an attachment.
Definition: mutt_attach.c:254
String manipulation buffer.
Definition: buffer.h:33
#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:93
WHERE bool C_PgpAutoinline
Config: Use old-style inline PGP messages (not recommended)
Definition: globals.h:277
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:179
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:99
int crypt_get_keys(struct Email *e, char **keylist, bool oppenc_mode)
Check we have all the keys we need.
Definition: crypt.c:950
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:309
#define SEC_ENCRYPT
Email is encrypted.
Definition: ncrypt.h:122
#define SEND_POSTPONED
Recall a postponed email.
Definition: send.h:92
void mutt_buffer_pretty_mailbox(struct Buffer *buf)
Shorten a mailbox path using &#39;~&#39; or &#39;=&#39;.
Definition: muttlib.c:703
bool C_CryptReplysign
Config: Sign replies to signed messages.
Definition: send.c:102
Messages that have been replied to.
Definition: mutt.h:99
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:3001
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:273
bool C_CryptAutosmime
Config: Allow automatic SMIME functions.
Definition: send.c:100
#define SEND_MAILX
Send email in Mailx compatibility mode.
Definition: send.h:94
void mutt_sleep(short s)
Sleep for a while.
Definition: muttlib.c:1545
WHERE bool C_EditHeaders
Config: Let the user edit the email headers whilst editing an email.
Definition: globals.h:210
struct Mailbox * mailbox
Definition: context.h:50
unsigned char C_Recall
Config: Recall postponed mesaages when asked to compose a message.
Definition: send.c:125
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:92
struct AddressList from
Email&#39;s &#39;From&#39; list.
Definition: envelope.h:57
enum MailboxType magic
Mailbox type.
Definition: mailbox.h:104
void mutt_update_encoding(struct Body *a)
Update the encoding type.
Definition: sendlib.c:1485
static void process_user_recips(struct Envelope *env)
Process the user headers.
Definition: send.c:351
int mutt_file_fclose(FILE **fp)
Close a FILE handle (and NULL the pointer)
Definition: file.c:152
struct Envelope * env
Envelope information.
Definition: email.h:89
static void decode_descriptions(struct Body *b)
rfc2047 decode them in case of an error
Definition: send.c:1465
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:201
void mutt_buffer_dealloc(struct Buffer *buf)
Release the memory allocated by a buffer.
Definition: buffer.c:294
#define SEND_LIST_REPLY
Reply to mailing list.
Definition: send.h:90
static bool is_reply(struct Email *reply, struct Email *orig)
Is one email a reply to another?
Definition: send.c:1551
void * mdata
Driver specific data.
Definition: mailbox.h:135
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:1746
#define SEND_KEY
Mail a PGP public key.
Definition: send.h:95
char * subtype
content-type subtype
Definition: body.h:37
#define mutt_b2s(buf)
Definition: buffer.h:41
bool C_FastReply
Config: Don&#39;t prompt for the recipients and subject when replying/forwarding.
Definition: send.c:105
#define SEND_RESEND
Reply using the current email as a template.
Definition: send.h:96
void mutt_unprepare_envelope(struct Envelope *env)
Undo the encodings of mutt_prepare_envelope()
Definition: sendlib.c:3040
#define mutt_mktemp(buf, buflen)
Definition: muttlib.h:75
#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:1334
WHERE bool C_CryptOpportunisticEncrypt
Config: Enable encryption when the recipient&#39;s key is available.
Definition: globals.h:269
bool C_ReverseName
Config: Set the &#39;From&#39; from the address the email was sent to.
Definition: send.c:129
User answered &#39;No&#39;, or assume &#39;No&#39;.
Definition: quad.h:39
void mutt_encode_descriptions(struct Body *b, bool recurse)
rfc2047 encode the content-descriptions
Definition: send.c:1448
void mutt_select_fcc(struct Buffer *path, struct Email *e)
Select the FCC path for an email.
Definition: hook.c:694
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:1102
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:170
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:102
#define STAILQ_FOREACH(var, head, field)
Definition: queue.h:349
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:1285
#define STAILQ_NEXT(elm, field)
Definition: queue.h:397
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:39
bool C_PgpReplyinline
Config: Reply using old-style inline PGP messages (not recommended)
Definition: send.c:121
#define SEND_REPLY
Reply to sender.
Definition: send.h:88
NNTP-specific Mailbox data -.
Definition: nntp.h:138
bool C_SigOnTop
Config: Insert the signature before the quoted text.
Definition: send.c:133
#define SEND_NO_FREE_HEADER
Used by the -E flag.
Definition: send.h:98
unsigned char C_ForwardEdit
Config: Automatically start the editor when forwarding a message.
Definition: send.c:112
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:101
int mutt_addrlist_count_recips(const struct AddressList *al)
Count the number of Addresses with valid recipients.
Definition: address.c:835
bool crypt_has_module_backend(SecurityFlags type)
Is there a crypto backend for a given type?
Definition: cryptglue.c:163
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:86
WHERE bool C_TextFlowed
Config: Generate &#39;format=flowed&#39; messages.
Definition: globals.h:257
void mutt_parse_content_type(const char *s, struct Body *ct)
Parse a content type.
Definition: parse.c:456
void mutt_env_to_local(struct Envelope *env)
Convert an Envelope&#39;s Address fields to local format.
Definition: envelope.c:271
void mutt_edit_headers(const char *editor, const char *body, struct Email *e, struct Buffer *fcc)
Let the user edit the message header and body.
Definition: mutt_header.c:168
void crypt_opportunistic_encrypt(struct Email *e)
Can all recipients be determined.
Definition: crypt.c:1028
WHERE bool C_ResumeDraftFiles
Config: Process draft files like postponed messages.
Definition: globals.h:247
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:40
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:270
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:116
#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:424
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:401
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:54
void mutt_rfc3676_space_stuff(struct Email *e)
Perform RFC3676 space stuffing on an Email.
Definition: rfc3676.c:467
static int edit_envelope(struct Envelope *en, SendFlags flags)
Edit Envelope fields.
Definition: send.c:242
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:109
bool C_UseFrom
Config: Set the &#39;From&#39; header for outgoing mail.
Definition: send.c:134
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:961
#define MUTT_REPLY_HOOK
reply-hook: when replying to an email
Definition: hook.h:55
#define FREE(x)
Definition: memory.h:40
#define MUTT_COMPOSE_NOFREEHEADER
Definition: compose.h:35
static int save_fcc(struct Email *e, struct Buffer *fcc, struct Body *clear_content, char *pgpkeylist, SendFlags flags, char **finalpath)
Save an Email to a &#39;sent mail&#39; folder.
Definition: send.c:1610
struct AddressList to
Email&#39;s &#39;To&#39; list.
Definition: envelope.h:58
List of Emails.
Definition: email.h:114
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:138
#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:573
void mutt_body_free(struct Body **ptr)
Free a Body.
Definition: body.c:57
#define TAILQ_EMPTY(head)
Definition: queue.h:714
WHERE bool OptNewsSend
(pseudo) used to change behavior when posting
Definition: options.h:44
Log at debug level 5.
Definition: logging.h:44
WHERE char * C_PgpSignAs
Config: Use this alternative key for signing messages.
Definition: globals.h:160
FILE * mutt_file_fopen(const char *path, const char *mode)
Call fopen() safely.
Definition: file.c:585
WHERE char * C_SmimeSignAs
Config: Use this alternative key for signing messages.
Definition: globals.h:164
static void append_signature(FILE *fp)
Append a signature to an email.
Definition: send.c:140
void email_free(struct Email **ptr)
Free an Email.
Definition: email.c:41
bool mutt_buffer_is_empty(const struct Buffer *buf)
Is the Buffer empty?
Definition: buffer.c:252
char * C_ContentType
Config: Default "Content-Type" for newly composed messages.
Definition: send.c:96
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:347
#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:352
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:1362
int mutt_get_postponed(struct Context *ctx, struct Email *hdr, struct Email **cur, struct Buffer *fcc)
Recall a postponed message.
Definition: postpone.c:328
Type: &#39;application/*&#39;.
Definition: mime.h:33
QuadOption
Possible values for a quad-option.
Definition: quad.h:36
int mutt_compose_menu(struct Email *e, struct Buffer *fcc, struct Email *e_cur, int flags)
Allow the user to edit the message envelope.
Definition: compose.c:1125
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:93
bool C_CryptReplysignencrypted
Config: Sign replies to encrypted messages.
Definition: send.c:103
bool C_NmRecord
Config: (notmuch) If the &#39;record&#39; mailbox (sent mail) should be indexed.
Definition: send.c:120
void mutt_addrlist_append(struct AddressList *al, struct Address *a)
Append an Address to an AddressList.
Definition: address.c:1402
#define APPLICATION_SMIME
Use SMIME to encrypt/sign.
Definition: ncrypt.h:135
void mutt_buffer_alloc(struct Buffer *buf, size_t new_size)
Make sure a buffer can store at least new_size bytes.
Definition: buffer.c:265
bool C_CryptAutopgp
Config: Allow automatic PGP functions.
Definition: send.c:98
bool C_CryptAutoencrypt
Config: Automatically PGP encrypt all outgoing mail.
Definition: send.c:97
bool C_ReplyWithXorig
Config: Create &#39;From&#39; header from &#39;X-Original-To&#39; header.
Definition: send.c:128
+ 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 90 of file send.c.

◆ C_AbortNoattachRegex

struct Regex* C_AbortNoattachRegex

Config: Regex to match text indicating attachments are expected.

Definition at line 91 of file send.c.

◆ C_AbortNosubject

unsigned char C_AbortNosubject

Config: Abort creating the email if subject is missing.

Definition at line 92 of file send.c.

◆ C_AbortUnmodified

unsigned char C_AbortUnmodified

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

Definition at line 93 of file send.c.

◆ C_AskFollowUp

bool C_AskFollowUp

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

Definition at line 94 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 95 of file send.c.

◆ C_ContentType

char* C_ContentType

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

Definition at line 96 of file send.c.

◆ C_CryptAutoencrypt

bool C_CryptAutoencrypt

Config: Automatically PGP encrypt all outgoing mail.

Definition at line 97 of file send.c.

◆ C_CryptAutopgp

bool C_CryptAutopgp

Config: Allow automatic PGP functions.

Definition at line 98 of file send.c.

◆ C_CryptAutosign

bool C_CryptAutosign

Config: Automatically PGP sign all outgoing mail.

Definition at line 99 of file send.c.

◆ C_CryptAutosmime

bool C_CryptAutosmime

Config: Allow automatic SMIME functions.

Definition at line 100 of file send.c.

◆ C_CryptReplyencrypt

bool C_CryptReplyencrypt

Config: Encrypt replies to encrypted messages.

Definition at line 101 of file send.c.

◆ C_CryptReplysign

bool C_CryptReplysign

Config: Sign replies to signed messages.

Definition at line 102 of file send.c.

◆ C_CryptReplysignencrypted

bool C_CryptReplysignencrypted

Config: Sign replies to encrypted messages.

Definition at line 103 of file send.c.

◆ C_EmptySubject

char* C_EmptySubject

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

Definition at line 104 of file send.c.

◆ C_FastReply

bool C_FastReply

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

Definition at line 105 of file send.c.

◆ C_FccAttach

unsigned char C_FccAttach

Config: Save send message with all their attachments.

Definition at line 106 of file send.c.

◆ C_FccBeforeSend

bool C_FccBeforeSend

Config: Save FCCs before sending the message.

Definition at line 107 of file send.c.

◆ C_FccClear

bool C_FccClear

Config: Save sent messages unencrypted and unsigned.

Definition at line 108 of file send.c.

◆ C_FollowupTo

bool C_FollowupTo

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

Definition at line 109 of file send.c.

◆ C_ForwardAttributionIntro

char* C_ForwardAttributionIntro

Config: Prefix message for forwarded messages.

Definition at line 110 of file send.c.

◆ C_ForwardAttributionTrailer

char* C_ForwardAttributionTrailer

Config: Suffix message for forwarded messages.

Definition at line 111 of file send.c.

◆ C_ForwardEdit

unsigned char C_ForwardEdit

Config: Automatically start the editor when forwarding a message.

Definition at line 112 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 113 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 114 of file send.c.

◆ C_Hdrs

bool C_Hdrs

Config: Add custom headers to outgoing mail.

Definition at line 115 of file send.c.

◆ C_HonorFollowupTo

unsigned char C_HonorFollowupTo

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

Definition at line 116 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 117 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 118 of file send.c.

◆ C_Metoo

bool C_Metoo

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

Definition at line 119 of file send.c.

◆ C_NmRecord

bool C_NmRecord

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

Definition at line 120 of file send.c.

◆ C_PgpReplyinline

bool C_PgpReplyinline

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

Definition at line 121 of file send.c.

◆ C_PostIndentString

char* C_PostIndentString

Config: Suffix message to add after reply text.

Definition at line 122 of file send.c.

◆ C_PostponeEncrypt

bool C_PostponeEncrypt

Config: Self-encrypt postponed messages.

Definition at line 123 of file send.c.

◆ C_PostponeEncryptAs

char* C_PostponeEncryptAs

Config: Fallback encryption key for postponed messages.

Definition at line 124 of file send.c.

◆ C_Recall

unsigned char C_Recall

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

Definition at line 125 of file send.c.

◆ C_ReplySelf

bool C_ReplySelf

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

Definition at line 126 of file send.c.

◆ C_ReplyTo

unsigned char C_ReplyTo

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

Definition at line 127 of file send.c.

◆ C_ReplyWithXorig

bool C_ReplyWithXorig

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

Definition at line 128 of file send.c.

◆ C_ReverseName

bool C_ReverseName

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

Definition at line 129 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 130 of file send.c.

◆ C_SigDashes

bool C_SigDashes

Config: Insert '– ' before the signature.

Definition at line 131 of file send.c.

◆ C_Signature

char* C_Signature

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

Definition at line 132 of file send.c.

◆ C_SigOnTop

bool C_SigOnTop

Config: Insert the signature before the quoted text.

Definition at line 133 of file send.c.

◆ C_UseFrom

bool C_UseFrom

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

Definition at line 134 of file send.c.