NeoMutt  2024-03-23-23-gec7045
Teaching an old dog new tricks
DOXYGEN
Loading...
Searching...
No Matches
send.h File Reference

Prepare and send an email. More...

#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
+ Include dependency graph for send.h:
+ This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros

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

Typedefs

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

Functions

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

Detailed Description

Prepare and send an email.

Authors
  • Richard Russon
  • Pietro Cerutti
  • Alejandro Colomar

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Definition in file send.h.

Macro Definition Documentation

◆ SEND_NO_FLAGS

#define SEND_NO_FLAGS   0

No flags are set.

Definition at line 41 of file send.h.

◆ SEND_REPLY

#define SEND_REPLY   (1 << 0)

Reply to sender.

Definition at line 42 of file send.h.

◆ SEND_GROUP_REPLY

#define SEND_GROUP_REPLY   (1 << 1)

Reply to all.

Definition at line 43 of file send.h.

◆ SEND_LIST_REPLY

#define SEND_LIST_REPLY   (1 << 2)

Reply to mailing list.

Definition at line 44 of file send.h.

◆ SEND_FORWARD

#define SEND_FORWARD   (1 << 3)

Forward email.

Definition at line 45 of file send.h.

◆ SEND_POSTPONED

#define SEND_POSTPONED   (1 << 4)

Recall a postponed email.

Definition at line 46 of file send.h.

◆ SEND_BATCH

#define SEND_BATCH   (1 << 5)

Send email in batch mode (without user interaction)

Definition at line 47 of file send.h.

◆ SEND_KEY

#define SEND_KEY   (1 << 6)

Mail a PGP public key.

Definition at line 48 of file send.h.

◆ SEND_RESEND

#define SEND_RESEND   (1 << 7)

Reply using the current email as a template.

Definition at line 49 of file send.h.

◆ SEND_POSTPONED_FCC

#define SEND_POSTPONED_FCC   (1 << 8)

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

Definition at line 50 of file send.h.

◆ SEND_NO_FREE_HEADER

#define SEND_NO_FREE_HEADER   (1 << 9)

Used by the -E flag.

Definition at line 51 of file send.h.

◆ SEND_DRAFT_FILE

#define SEND_DRAFT_FILE   (1 << 10)

Used by the -H flag.

Definition at line 52 of file send.h.

◆ SEND_TO_SENDER

#define SEND_TO_SENDER   (1 << 11)

Compose new email to sender.

Definition at line 53 of file send.h.

◆ SEND_GROUP_CHAT_REPLY

#define SEND_GROUP_CHAT_REPLY   (1 << 12)

Reply to all recipients preserving To/Cc.

Definition at line 54 of file send.h.

◆ SEND_NEWS

#define SEND_NEWS   (1 << 13)

Reply to a news article.

Definition at line 55 of file send.h.

◆ SEND_REVIEW_TO

#define SEND_REVIEW_TO   (1 << 14)

Allow the user to edit the To field.

Definition at line 56 of file send.h.

◆ SEND_CONSUMED_STDIN

#define SEND_CONSUMED_STDIN   (1 << 15)

stdin has been read; don't read it twice

Definition at line 57 of file send.h.

◆ SEND_CLI_CRYPTO

#define SEND_CLI_CRYPTO   (1 << 16)

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

Definition at line 58 of file send.h.

Typedef Documentation

◆ SendFlags

typedef uint32_t SendFlags

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

Definition at line 40 of file send.h.

Function Documentation

◆ mutt_add_to_reference_headers()

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

Generate references for a reply email.

Parameters
envEnvelope for result
env_curEnvelope of source email
subConfig Subset

Definition at line 1104 of file send.c.

1106{
1107 add_references(&env->references, env_cur);
1108 add_message_id(&env->references, env_cur);
1109 add_message_id(&env->in_reply_to, env_cur);
1110
1111 const bool c_x_comment_to = cs_subset_bool(sub, "x_comment_to");
1112 if (OptNewsSend && c_x_comment_to && !TAILQ_EMPTY(&env_cur->from))
1114}
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:48
bool OptNewsSend
(pseudo) used to change behavior when posting
Definition: globals.c:71
char * mutt_str_dup(const char *str)
Copy a string, safely.
Definition: string.c:253
#define TAILQ_FIRST(head)
Definition: queue.h:723
#define TAILQ_EMPTY(head)
Definition: queue.h:721
static void add_message_id(struct ListHead *head, struct Envelope *env)
Add the email's message ID to a list.
Definition: send.c:1013
static void add_references(struct ListHead *head, struct Envelope *env)
Add the email's references to a list.
Definition: send.c:997
const char * mutt_get_name(const struct Address *a)
Pick the best name to display from an address.
Definition: sort.c:134
char * x_comment_to
List of 'X-comment-to' fields.
Definition: envelope.h:81
struct ListHead references
message references (in reverse order)
Definition: envelope.h:83
struct ListHead in_reply_to
in-reply-to header content
Definition: envelope.h:84
struct AddressList from
Email's 'From' list.
Definition: envelope.h:59
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_default_from()

struct Address * mutt_default_from ( struct ConfigSubset sub)

Get a default 'from' Address.

Parameters
subConfig Subset
Return values
ptrNewly allocated Address

Definition at line 1465 of file send.c.

1466{
1467 /* Note: We let $from override $real_name here.
1468 * Is this the right thing to do?
1469 */
1470
1471 const struct Address *c_from = cs_subset_address(sub, "from");
1472 if (c_from)
1473 {
1474 return mutt_addr_copy(c_from);
1475 }
1476
1477 char domain[1024] = { 0 };
1478 const char *mailbox = Username;
1479 const bool c_use_domain = cs_subset_bool(sub, "use_domain");
1480 if (c_use_domain)
1481 {
1482 snprintf(domain, sizeof(domain), "%s@%s", NONULL(Username),
1483 NONULL(mutt_fqdn(true, sub)));
1484 mailbox = domain;
1485 }
1486
1487 return mutt_addr_create(NULL, mailbox);
1488}
struct Address * mutt_addr_create(const char *personal, const char *mailbox)
Create and populate a new Address.
Definition: address.c:414
struct Address * mutt_addr_copy(const struct Address *addr)
Copy the real address.
Definition: address.c:745
const struct Address * cs_subset_address(const struct ConfigSubset *sub, const char *name)
Get an Address config item by name.
Definition: config_type.c:273
char * Username
User's login name.
Definition: globals.c:41
const char * mutt_fqdn(bool may_hide_host, const struct ConfigSubset *sub)
Get the Fully-Qualified Domain Name.
Definition: sendlib.c:706
#define NONULL(x)
Definition: string2.h:37
An email address.
Definition: address.h:36
struct Buffer * mailbox
Mailbox and host address.
Definition: address.h:38
+ 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 193 of file send.c.

194{
195 int rc = 0;
196 struct Buffer *buf = buf_pool_get();
197 buf_alloc(buf, 8192);
198 char *err = NULL;
199 int idna_ok = 0;
200
201 do
202 {
204 buf_reset(buf);
205 mutt_addrlist_write(al, buf, false);
206 if (mw_get_field(field, buf, MUTT_COMP_NO_FLAGS, HC_ALIAS, &CompleteAliasOps, NULL) != 0)
207 {
208 rc = -1;
209 goto done;
210 }
213 if (expand_aliases)
215 idna_ok = mutt_addrlist_to_intl(al, &err);
216 if (idna_ok != 0)
217 {
218 mutt_error(_("Bad IDN: '%s'"), err);
219 FREE(&err);
220 }
221 } while (idna_ok != 0);
222
223done:
224 buf_pool_release(&buf);
225 return rc;
226}
void mutt_addrlist_clear(struct AddressList *al)
Unlink and free all Address in an AddressList.
Definition: address.c:1464
int mutt_addrlist_to_local(struct AddressList *al)
Convert an Address list from Punycode.
Definition: address.c:1382
size_t mutt_addrlist_write(const struct AddressList *al, struct Buffer *buf, bool display)
Write an Address to a buffer.
Definition: address.c:1210
int mutt_addrlist_parse2(struct AddressList *al, const char *s)
Parse a list of email addresses.
Definition: address.c:644
int mutt_addrlist_to_intl(struct AddressList *al, char **err)
Convert an Address list to Punycode.
Definition: address.c:1297
const struct CompleteOps CompleteAliasOps
Auto-Completion of Aliases.
Definition: complete.c:108
void mutt_expand_aliases(struct AddressList *al)
Expand aliases in a List of Addresses.
Definition: alias.c:300
void buf_reset(struct Buffer *buf)
Reset an existing Buffer.
Definition: buffer.c:93
void buf_alloc(struct Buffer *buf, size_t new_size)
Make sure a buffer can store at least new_size bytes.
Definition: buffer.c:354
static const char * buf_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:97
int mw_get_field(const char *prompt, struct Buffer *buf, CompletionFlags complete, enum HistoryClass hclass, const struct CompleteOps *comp_api, void *cdata)
Ask the user for a string -.
Definition: window.c:274
#define mutt_error(...)
Definition: logging2.h:92
@ HC_ALIAS
Aliases.
Definition: lib.h:52
#define FREE(x)
Definition: memory.h:45
#define _(a)
Definition: message.h:28
#define MUTT_COMP_NO_FLAGS
No flags are set.
Definition: mutt.h:56
struct Buffer * buf_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:81
void buf_pool_release(struct Buffer **ptr)
Return a Buffer to the pool.
Definition: pool.c:94
String manipulation buffer.
Definition: buffer.h:36
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_encode_descriptions()

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

RFC2047 encode the content-descriptions.

Parameters
bBody of email
recurseIf true, encode children parts
subConfig Subset

Definition at line 1575 of file send.c.

1576{
1577 const struct Slist *const c_send_charset = cs_subset_slist(sub, "send_charset");
1578 for (struct Body *t = b; t; t = t->next)
1579 {
1580 if (t->description)
1581 {
1582 rfc2047_encode(&t->description, NULL, sizeof("Content-Description:"), c_send_charset);
1583 }
1584 if (recurse && t->parts)
1585 mutt_encode_descriptions(t->parts, recurse, sub);
1586 }
1587}
const struct Slist * cs_subset_slist(const struct ConfigSubset *sub, const char *name)
Get a string-list config item by name.
Definition: helpers.c:243
void rfc2047_encode(char **pd, const char *specials, int col, const struct Slist *charsets)
RFC-2047-encode a string.
Definition: rfc2047.c:628
void mutt_encode_descriptions(struct Body *b, bool recurse, struct ConfigSubset *sub)
RFC2047 encode the content-descriptions.
Definition: send.c:1575
The body of an email.
Definition: body.h:36
struct Body * next
next attachment in the list
Definition: body.h:71
String list.
Definition: slist.h:37
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_fetch_recips()

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

Generate recpients for a reply email.

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

Definition at line 938 of file send.c.

940{
941 enum QuadOption hmfupto = MUTT_ABORT;
942 const struct Address *followup_to = TAILQ_FIRST(&in->mail_followup_to);
943
944 if ((flags & (SEND_LIST_REPLY | SEND_GROUP_REPLY | SEND_GROUP_CHAT_REPLY)) && followup_to)
945 {
946 char prompt[256] = { 0 };
947 snprintf(prompt, sizeof(prompt), _("Follow-up to %s%s?"),
948 buf_string(followup_to->mailbox),
949 TAILQ_NEXT(TAILQ_FIRST(&in->mail_followup_to), entries) ? ",..." : "");
950
951 hmfupto = query_quadoption(prompt, sub, "honor_followup_to");
952 if (hmfupto == MUTT_ABORT)
953 return -1;
954 }
955
956 if (flags & SEND_LIST_REPLY)
957 {
958 add_mailing_lists(&out->to, &in->to, &in->cc);
959
960 if (followup_to && (hmfupto == MUTT_YES) &&
961 (default_to(&out->cc, in, flags & SEND_LIST_REPLY, (hmfupto == MUTT_YES), sub) == MUTT_ABORT))
962 {
963 return -1; /* abort */
964 }
965 }
966 else if (flags & SEND_TO_SENDER)
967 {
968 mutt_addrlist_copy(&out->to, &in->from, false);
969 }
970 else
971 {
972 if (default_to(&out->to, in, flags & (SEND_GROUP_REPLY | SEND_GROUP_CHAT_REPLY),
973 (hmfupto == MUTT_YES), sub) == -1)
974 {
975 return -1; /* abort */
976 }
977
978 if ((flags & (SEND_GROUP_REPLY | SEND_GROUP_CHAT_REPLY)) &&
979 (!followup_to || (hmfupto != MUTT_YES)))
980 {
981 /* if(!mutt_addr_is_user(in->to)) */
982 if (flags & SEND_GROUP_REPLY)
983 mutt_addrlist_copy(&out->cc, &in->to, true);
984 else
985 mutt_addrlist_copy(&out->to, &in->to, true);
986 mutt_addrlist_copy(&out->cc, &in->cc, true);
987 }
988 }
989 return 0;
990}
void mutt_addrlist_copy(struct AddressList *dst, const struct AddressList *src, bool prune)
Copy a list of addresses into another list.
Definition: address.c:765
QuadOption
Possible values for a quad-option.
Definition: quad.h:36
@ MUTT_ABORT
User aborted the question (with Ctrl-G)
Definition: quad.h:37
@ MUTT_YES
User answered 'Yes', or assume 'Yes'.
Definition: quad.h:39
enum QuadOption query_quadoption(const char *prompt, struct ConfigSubset *sub, const char *name)
Ask the user a quad-question.
Definition: question.c:366
#define TAILQ_NEXT(elm, field)
Definition: queue.h:832
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:166
static int default_to(struct AddressList *to, struct Envelope *env, SendFlags flags, int hmfupto, struct ConfigSubset *sub)
Generate default email addresses.
Definition: send.c:852
#define SEND_GROUP_CHAT_REPLY
Reply to all recipients preserving To/Cc.
Definition: send.h:54
#define SEND_GROUP_REPLY
Reply to all.
Definition: send.h:43
#define SEND_LIST_REPLY
Reply to mailing list.
Definition: send.h:44
#define SEND_TO_SENDER
Compose new email to sender.
Definition: send.h:53
struct AddressList to
Email's 'To' list.
Definition: envelope.h:60
struct AddressList mail_followup_to
Email's 'mail-followup-to'.
Definition: envelope.h:65
struct AddressList cc
Email's 'Cc' list.
Definition: envelope.h:61
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_fix_reply_recipients()

void mutt_fix_reply_recipients ( struct Envelope env,
struct ConfigSubset sub 
)

Remove duplicate recipients.

Parameters
envEnvelope to fix
subConfig Subset

Definition at line 1026 of file send.c.

1027{
1028 const bool c_me_too = cs_subset_bool(sub, "me_too");
1029 if (!c_me_too)
1030 {
1031 const bool c_reply_self = cs_subset_bool(sub, "reply_self");
1032
1033 /* the order is important here. do the CC: first so that if the
1034 * the user is the only recipient, it ends up on the TO: field */
1035 remove_user(&env->cc, TAILQ_EMPTY(&env->to));
1036 remove_user(&env->to, TAILQ_EMPTY(&env->cc) || c_reply_self);
1037 }
1038
1039 /* the CC field can get cluttered, especially with lists */
1040 mutt_addrlist_dedupe(&env->to);
1041 mutt_addrlist_dedupe(&env->cc);
1042 mutt_addrlist_remove_xrefs(&env->to, &env->cc);
1043
1044 if (!TAILQ_EMPTY(&env->cc) && TAILQ_EMPTY(&env->to))
1045 {
1046 TAILQ_SWAP(&env->to, &env->cc, Address, entries);
1047 }
1048}
void mutt_addrlist_remove_xrefs(const struct AddressList *a, struct AddressList *b)
Remove cross-references.
Definition: address.c:1437
void mutt_addrlist_dedupe(struct AddressList *al)
Remove duplicate addresses.
Definition: address.c:1401
#define TAILQ_SWAP(head1, head2, type, field)
Definition: queue.h:859
static void remove_user(struct AddressList *al, bool leave_only)
Remove any address which matches the current user.
Definition: send.c:147
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_forward_intro()

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

Add the "start of forwarded message" text.

Parameters
eEmail
subConfig Subset
fpFile to write to

Definition at line 454 of file send.c.

455{
456 const struct Expando *c_forward_attribution_intro = cs_subset_expando(sub, "forward_attribution_intro");
457 if (!c_forward_attribution_intro || !fp)
458 return;
459
460 const char *const c_attribution_locale = cs_subset_string(sub, "attribution_locale");
461
462 struct Buffer *buf = buf_pool_get();
463 setlocale(LC_TIME, NONULL(c_attribution_locale));
464 mutt_make_string(buf, -1, c_forward_attribution_intro, NULL, -1, e,
466 setlocale(LC_TIME, "");
467 fputs(buf_string(buf), fp);
468 fputs("\n\n", fp);
469 buf_pool_release(&buf);
470}
const char * cs_subset_string(const struct ConfigSubset *sub, const char *name)
Get a string config item by name.
Definition: helpers.c:292
const struct Expando * cs_subset_expando(const struct ConfigSubset *sub, const char *name)
Get an Expando config item by name.
Definition: config_type.c:297
int mutt_make_string(struct Buffer *buf, size_t max_cols, const struct Expando *exp, struct Mailbox *m, int inpgr, struct Email *e, MuttFormatFlags flags, const char *progress)
Create formatted strings using mailbox expandos.
Definition: hdrline.c:1797
#define MUTT_FORMAT_NO_FLAGS
No flags are set.
Definition: render.h:33
Parsed Expando trees.
Definition: expando.h:41
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_forward_trailer()

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

Add a "end of forwarded message" text.

Parameters
eEmail
subConfig Subset
fpFile to write to

Definition at line 478 of file send.c.

479{
480 const struct Expando *c_forward_attribution_trailer = cs_subset_expando(sub, "forward_attribution_trailer");
481 if (!c_forward_attribution_trailer || !fp)
482 return;
483
484 const char *const c_attribution_locale = cs_subset_string(sub, "attribution_locale");
485
486 struct Buffer *buf = buf_pool_get();
487 setlocale(LC_TIME, NONULL(c_attribution_locale));
488 mutt_make_string(buf, -1, c_forward_attribution_trailer, NULL, -1, e,
490 setlocale(LC_TIME, "");
491 fputc('\n', fp);
492 fputs(buf_string(buf), fp);
493 fputc('\n', fp);
494 buf_pool_release(&buf);
495}
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_make_attribution_intro()

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

Add "on DATE, PERSON wrote" header.

Parameters
eEmail
fp_outFile to write to
subConfig Subset

Definition at line 662 of file send.c.

663{
664 format_attribution(cs_subset_expando(sub, "attribution_intro"), e, fp_out, sub);
665}
static void format_attribution(const struct Expando *exp, struct Email *e, FILE *fp_out, struct ConfigSubset *sub)
Format an attribution prefix/suffix.
Definition: send.c:639
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_make_attribution_trailer()

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

Add suffix to replied email text.

Parameters
eEmail
fp_outFile to write to
subConfig Subset

Definition at line 673 of file send.c.

674{
675 format_attribution(cs_subset_expando(sub, "attribution_trailer"), e, fp_out, sub);
676}
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_make_forward_subject()

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

Create a subject for a forwarded email.

Parameters
envEnvelope for result
eEmail
subConfig Subset

Definition at line 1056 of file send.c.

1057{
1058 if (!env)
1059 return;
1060
1061 const struct Expando *c_forward_format = cs_subset_expando(sub, "forward_format");
1062
1063 struct Buffer *buf = buf_pool_get();
1064 /* set the default subject for the message. */
1065 mutt_make_string(buf, -1, c_forward_format, NULL, -1, e, MUTT_FORMAT_NO_FLAGS, NULL);
1067 buf_pool_release(&buf);
1068}
void mutt_env_set_subject(struct Envelope *env, const char *subj)
Set both subject and real_subj to subj.
Definition: envelope.c:69
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_make_misc_reply_headers()

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

Set subject for a reply.

Parameters
envEnvelope for result
env_curEnvelope of source email
subConfig Subset

Definition at line 1076 of file send.c.

1078{
1079 if (!env || !env_cur)
1080 return;
1081
1082 /* This takes precedence over a subject that might have
1083 * been taken from a List-Post header. Is that correct? */
1084 if (env_cur->real_subj)
1085 {
1086 char *subj = NULL;
1087 mutt_str_asprintf(&subj, "Re: %s", env_cur->real_subj);
1088 mutt_env_set_subject(env, subj);
1089 FREE(&subj);
1090 }
1091 else if (!env->subject)
1092 {
1093 const char *const c_empty_subject = cs_subset_string(sub, "empty_subject");
1094 mutt_env_set_subject(env, c_empty_subject);
1095 }
1096}
int mutt_str_asprintf(char **strp, const char *fmt,...)
Definition: string.c:852
char *const subject
Email's subject.
Definition: envelope.h:70
char *const real_subj
Offset of the real subject.
Definition: envelope.h:71
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_resend_message()

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

Resend an email.

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

Definition at line 1635 of file send.c.

1637{
1638 struct Email *e_new = email_new();
1639
1640 if (mutt_prepare_template(fp, m, e_new, e_cur, true) < 0)
1641 {
1642 email_free(&e_new);
1643 return -1;
1644 }
1645
1646 if (WithCrypto)
1647 {
1648 /* mutt_prepare_template doesn't always flip on an application bit.
1649 * so fix that here */
1650 if (!(e_new->security & (APPLICATION_SMIME | APPLICATION_PGP)))
1651 {
1652 const bool c_smime_is_default = cs_subset_bool(sub, "smime_is_default");
1653 if (((WithCrypto & APPLICATION_SMIME) != 0) && c_smime_is_default)
1654 e_new->security |= APPLICATION_SMIME;
1655 else if (WithCrypto & APPLICATION_PGP)
1656 e_new->security |= APPLICATION_PGP;
1657 else
1658 e_new->security |= APPLICATION_SMIME;
1659 }
1660
1661 const bool c_crypt_opportunistic_encrypt = cs_subset_bool(sub, "crypt_opportunistic_encrypt");
1662 if (c_crypt_opportunistic_encrypt)
1663 {
1664 e_new->security |= SEC_OPPENCRYPT;
1666 }
1667 }
1668
1669 struct EmailArray ea = ARRAY_HEAD_INITIALIZER;
1670 ARRAY_ADD(&ea, e_cur);
1671 int rc = mutt_send_message(SEND_RESEND, e_new, NULL, m, &ea, sub);
1672 ARRAY_FREE(&ea);
1673
1674 return rc;
1675}
#define ARRAY_ADD(head, elem)
Add an element at the end of the array.
Definition: array.h:156
#define ARRAY_FREE(head)
Release all memory.
Definition: array.h:204
#define ARRAY_HEAD_INITIALIZER
Static initializer for arrays.
Definition: array.h:58
void crypt_opportunistic_encrypt(struct Email *e)
Can all recipients be determined.
Definition: crypt.c:1031
struct Email * email_new(void)
Create a new Email.
Definition: email.c:80
void email_free(struct Email **ptr)
Free an Email.
Definition: email.c:46
#define SEC_OPPENCRYPT
Opportunistic encrypt mode.
Definition: lib.h:86
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: lib.h:90
#define APPLICATION_SMIME
Use SMIME to encrypt/sign.
Definition: lib.h:91
#define WithCrypto
Definition: lib.h:116
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:483
int mutt_send_message(SendFlags flags, struct Email *e_templ, const char *tempfile, struct Mailbox *m, struct EmailArray *ea, struct ConfigSubset *sub)
Send an email.
Definition: send.c:2120
#define SEND_RESEND
Reply using the current email as a template.
Definition: send.h:49
The envelope/body of an email.
Definition: email.h:39
SecurityFlags security
bit 0-10: flags, bit 11,12: application, bit 13: traditional pgp See: ncrypt/lib.h pgplib....
Definition: email.h:43
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_send_message()

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

Send an email.

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

Definition at line 2120 of file send.c.

2122{
2123 struct Buffer fcc = buf_make(0); /* where to copy this message */
2124 FILE *fp_tmp = NULL;
2125 struct Body *pbody = NULL;
2126 int i;
2127 bool free_clear_content = false;
2128
2129 struct Body *clear_content = NULL;
2130 char *pgpkeylist = NULL;
2131 /* save current value of "pgp_sign_as" and "smime_default_key" */
2132 char *pgp_sign_as = NULL;
2133 char *smime_sign_as = NULL;
2134 const char *tag = NULL;
2135 char *err = NULL;
2136 const char *ctype = NULL;
2137 char *finalpath = NULL;
2138 struct Email *e_cur = NULL;
2139
2140 if (ea && (ARRAY_SIZE(ea) == 1))
2141 e_cur = *ARRAY_GET(ea, 0);
2142
2143 int rc = -1;
2144
2145 if (flags & SEND_NEWS)
2146 OptNewsSend = true;
2147 else
2148 OptNewsSend = false;
2149
2150 const enum QuadOption c_recall = cs_subset_quad(sub, "recall");
2151
2152 if (!flags && !e_templ && (c_recall != MUTT_NO) && mutt_num_postponed(m, true))
2153 {
2154 /* If the user is composing a new message, check to see if there
2155 * are any postponed messages first. */
2156 enum QuadOption ans = query_quadoption(_("Recall postponed message?"), sub, "recall");
2157 if (ans == MUTT_ABORT)
2158 return rc;
2159
2160 if (ans == MUTT_YES)
2161 flags |= SEND_POSTPONED;
2162 }
2163
2164 /* Allocate the buffer due to the long lifetime, but
2165 * pre-resize it to ensure there are no NULL data field issues */
2166 buf_alloc(&fcc, 1024);
2167
2168 if (flags & SEND_POSTPONED)
2169 {
2171 {
2172 const char *const c_pgp_sign_as = cs_subset_string(sub, "pgp_sign_as");
2173 pgp_sign_as = mutt_str_dup(c_pgp_sign_as);
2174 }
2176 {
2177 const char *const c_smime_sign_as = cs_subset_string(sub, "smime_sign_as");
2178 smime_sign_as = mutt_str_dup(c_smime_sign_as);
2179 }
2180 }
2181
2182 /* Delay expansion of aliases until absolutely necessary--shouldn't
2183 * be necessary unless we are prompting the user or about to execute a
2184 * send-hook. */
2185
2186 if (!e_templ)
2187 {
2188 e_templ = email_new();
2189
2190 if (flags == SEND_POSTPONED)
2191 {
2192 rc = mutt_get_postponed(m, e_templ, &e_cur, &fcc);
2193 if (rc < 0)
2194 {
2195 flags = SEND_POSTPONED;
2196 goto cleanup;
2197 }
2198 flags = rc;
2199 /* If postponed message is a news article, it have
2200 * a "Newsgroups:" header line, then set appropriate flag. */
2201 if (e_templ->env->newsgroups)
2202 {
2203 flags |= SEND_NEWS;
2204 OptNewsSend = true;
2205 }
2206 else
2207 {
2208 flags &= ~SEND_NEWS;
2209 OptNewsSend = false;
2210 }
2211 }
2212
2213 if (flags & (SEND_POSTPONED | SEND_RESEND))
2214 {
2215 struct Body *b = e_templ->body;
2216 while (b->parts)
2217 b = b->parts;
2218 fp_tmp = mutt_file_fopen(b->filename, "a+");
2219 if (!fp_tmp)
2220 {
2221 mutt_perror("%s", b->filename);
2222 goto cleanup;
2223 }
2224 }
2225
2226 if (!e_templ->env)
2227 e_templ->env = mutt_env_new();
2228 }
2229
2230 /* Parse and use an eventual list-post header */
2231 if ((flags & SEND_LIST_REPLY) && e_cur && e_cur->env && e_cur->env->list_post)
2232 {
2233 /* Use any list-post header as a template */
2234 mutt_parse_mailto(e_templ->env, NULL, e_cur->env->list_post);
2235 /* We don't let them set the sender's address. */
2236 mutt_addrlist_clear(&e_templ->env->from);
2237 }
2238
2239 if (!(flags & (SEND_KEY | SEND_POSTPONED | SEND_RESEND)))
2240 {
2241 /* When SEND_DRAFT_FILE is set, the caller has already
2242 * created the "parent" body structure. */
2243 if (!(flags & SEND_DRAFT_FILE))
2244 {
2245 pbody = mutt_body_new();
2246 pbody->next = e_templ->body; /* don't kill command-line attachments */
2247 e_templ->body = pbody;
2248
2249 const char *const c_content_type = cs_subset_string(sub, "content_type");
2250 ctype = c_content_type;
2251 if (!ctype)
2252 ctype = "text/plain";
2253 mutt_parse_content_type(ctype, e_templ->body);
2254 e_templ->body->unlink = true;
2255 e_templ->body->use_disp = false;
2256 e_templ->body->disposition = DISP_INLINE;
2257
2258 if (tempfile)
2259 {
2260 fp_tmp = mutt_file_fopen(tempfile, "a+");
2261 e_templ->body->filename = mutt_str_dup(tempfile);
2262 if (flags & SEND_NO_FREE_HEADER)
2263 e_templ->body->unlink = false;
2264 }
2265 else
2266 {
2267 struct Buffer *buf = buf_pool_get();
2268 buf_mktemp(buf);
2269 fp_tmp = mutt_file_fopen(buf_string(buf), "w+");
2270 e_templ->body->filename = buf_strdup(buf);
2271 buf_pool_release(&buf);
2272 }
2273 }
2274 else
2275 {
2276 struct Body *b = e_templ->body;
2277 while (b->parts)
2278 b = b->parts;
2279 fp_tmp = mutt_file_fopen(b->filename, "a+");
2280 }
2281
2282 if (!fp_tmp)
2283 {
2284 mutt_debug(LL_DEBUG1, "can't create tempfile %s (errno=%d)\n",
2285 e_templ->body->filename, errno);
2286 mutt_perror("%s", e_templ->body->filename);
2287 goto cleanup;
2288 }
2289 }
2290
2291 const bool c_reverse_name = cs_subset_bool(sub, "reverse_name");
2292 /* this is handled here so that the user can match ~f in send-hook */
2293 if (e_cur && c_reverse_name && !(flags & (SEND_POSTPONED | SEND_RESEND)))
2294 {
2295 /* We shouldn't have to worry about alias expansion here since we are
2296 * either replying to a real or postponed message, therefore no aliases
2297 * should exist since the user has not had the opportunity to add
2298 * addresses to the list. We just have to ensure the postponed messages
2299 * have their aliases expanded. */
2300
2301 if (!TAILQ_EMPTY(&e_templ->env->from))
2302 {
2303 mutt_debug(LL_DEBUG5, "e_templ->env->from before set_reverse_name: %s\n",
2304 buf_string(TAILQ_FIRST(&e_templ->env->from)->mailbox));
2305 mutt_addrlist_clear(&e_templ->env->from);
2306 }
2307 set_reverse_name(&e_templ->env->from, e_cur->env, sub);
2308 }
2309
2310 const bool c_reply_with_xorig = cs_subset_bool(sub, "reply_with_xorig");
2311 if (e_cur && c_reply_with_xorig && !(flags & (SEND_POSTPONED | SEND_RESEND | SEND_FORWARD)))
2312 {
2313 /* We shouldn't have to worry about freeing 'e_templ->env->from' before
2314 * setting it here since this code will only execute when doing some
2315 * sort of reply. The pointer will only be set when using the -H command
2316 * line option.
2317 *
2318 * If there is already a from address recorded in 'e_templ->env->from',
2319 * then it theoretically comes from `$reverse_name` handling, and we don't use
2320 * the 'X-Orig-To header'. */
2321 if (!TAILQ_EMPTY(&e_cur->env->x_original_to) && TAILQ_EMPTY(&e_templ->env->from))
2322 {
2323 mutt_addrlist_copy(&e_templ->env->from, &e_cur->env->x_original_to, false);
2324 mutt_debug(LL_DEBUG5, "e_templ->env->from extracted from X-Original-To: header: %s\n",
2325 buf_string(TAILQ_FIRST(&e_templ->env->from)->mailbox));
2326 }
2327 }
2328
2329 const bool c_resume_draft_files = cs_subset_bool(sub, "resume_draft_files");
2330 if (!(flags & (SEND_POSTPONED | SEND_RESEND)) &&
2331 !((flags & SEND_DRAFT_FILE) && c_resume_draft_files))
2332 {
2333 if ((flags & (SEND_REPLY | SEND_FORWARD | SEND_TO_SENDER)) &&
2334 (envelope_defaults(e_templ->env, ea, flags, sub) == -1))
2335 {
2336 goto cleanup;
2337 }
2338
2339 const bool c_hdrs = cs_subset_bool(sub, "hdrs");
2340 if (c_hdrs)
2341 process_user_recips(e_templ->env);
2342
2343 /* Expand aliases and remove duplicates/crossrefs */
2344 mutt_expand_aliases_env(e_templ->env);
2345
2346 if (flags & SEND_REPLY)
2347 mutt_fix_reply_recipients(e_templ->env, sub);
2348
2349 if ((flags & SEND_NEWS) && (m && m->type == MUTT_NNTP) && !e_templ->env->newsgroups)
2350 {
2351 e_templ->env->newsgroups = mutt_str_dup(((struct NntpMboxData *) m->mdata)->group);
2352 }
2353
2354 const bool c_auto_edit = cs_subset_bool(sub, "auto_edit");
2355 const bool c_edit_headers = cs_subset_bool(sub, "edit_headers");
2356 const bool c_fast_reply = cs_subset_bool(sub, "fast_reply");
2357 if (!(flags & SEND_BATCH) && !(c_auto_edit && c_edit_headers) &&
2358 !((flags & SEND_REPLY) && c_fast_reply))
2359 {
2360 if (edit_envelope(e_templ->env, flags, sub) == -1)
2361 goto cleanup;
2362 }
2363
2364 /* the from address must be set here regardless of whether or not
2365 * $use_from is set so that the '~P' (from you) operator in send-hook
2366 * patterns will work. if $use_from is unset, the from address is killed
2367 * after send-hooks are evaluated */
2368
2369 const bool killfrom = TAILQ_EMPTY(&e_templ->env->from);
2370 if (killfrom)
2371 {
2373 }
2374
2375 if ((flags & SEND_REPLY) && e_cur)
2376 {
2377 /* change setting based upon message we are replying to */
2379
2380 /* set the replied flag for the message we are generating so that the
2381 * user can use ~Q in a send-hook to know when reply-hook's are also
2382 * being used. */
2383 e_templ->replied = true;
2384 }
2385
2386 /* change settings based upon recipients */
2387
2388 mutt_message_hook(NULL, e_templ, MUTT_SEND_HOOK);
2389
2390 /* Unset the replied flag from the message we are composing since it is
2391 * no longer required. This is done here because the FCC'd copy of
2392 * this message was erroneously get the 'R'eplied flag when stored in
2393 * a maildir-style mailbox. */
2394 e_templ->replied = false;
2395
2396 /* $use_from and/or $from might have changed in a send-hook */
2397 if (killfrom)
2398 {
2399 mutt_addrlist_clear(&e_templ->env->from);
2400
2401 const bool c_use_from = cs_subset_bool(sub, "use_from");
2402 if (c_use_from && !(flags & (SEND_POSTPONED | SEND_RESEND)))
2404 }
2405
2406 if (c_hdrs)
2407 process_user_header(e_templ->env);
2408
2409 if ((flags & SEND_BATCH) && !(flags & SEND_CONSUMED_STDIN))
2410 {
2411 if (mutt_file_copy_stream(stdin, fp_tmp) < 0)
2412 {
2413 mutt_error(_("Error sending message"));
2414 goto cleanup;
2415 }
2416 }
2417
2418 if (!(flags & SEND_BATCH))
2419 mutt_make_greeting(e_templ, fp_tmp, sub);
2420
2421 const bool c_sig_on_top = cs_subset_bool(sub, "sig_on_top");
2422 const char *const c_editor = cs_subset_string(sub, "editor");
2423 if (c_sig_on_top && !(flags & (SEND_KEY | SEND_BATCH)) && c_editor)
2424 {
2425 append_signature(fp_tmp, sub);
2426 }
2427
2428 /* include replies/forwarded messages, unless we are given a template */
2429 if (!tempfile && (m || !(flags & (SEND_REPLY | SEND_FORWARD))) &&
2430 (generate_body(fp_tmp, e_templ, flags, m, ea, sub) == -1))
2431 {
2432 goto cleanup;
2433 }
2434
2435 if (!c_sig_on_top && !(flags & (SEND_KEY | SEND_BATCH)) && c_editor)
2436 {
2437 append_signature(fp_tmp, sub);
2438 }
2439 }
2440
2441 /* Only set format=flowed for new messages. postponed/resent/draftfiles
2442 * should respect the original email.
2443 *
2444 * This is set here so that send-hook can be used to turn the option on. */
2445 if (!(flags & (SEND_KEY | SEND_POSTPONED | SEND_RESEND | SEND_DRAFT_FILE)))
2446 {
2447 const bool c_text_flowed = cs_subset_bool(sub, "text_flowed");
2448 if (c_text_flowed && is_text_plain(e_templ->body))
2449 {
2450 mutt_param_set(&e_templ->body->parameter, "format", "flowed");
2451 }
2452 }
2453
2454 /* This hook is even called for postponed messages, and can, e.g., be used
2455 * for setting the editor, the sendmail path, or the envelope sender. */
2456 mutt_message_hook(NULL, e_templ, MUTT_SEND2_HOOK);
2457
2458 /* wait until now to set the real name portion of our return address so
2459 * that $real_name can be set in a send-hook */
2460 {
2461 struct Address *from = TAILQ_FIRST(&e_templ->env->from);
2462 if (from && !from->personal && !(flags & (SEND_RESEND | SEND_POSTPONED)))
2463 {
2464 const char *const c_real_name = cs_subset_string(sub, "real_name");
2465 if (c_real_name)
2466 from->personal = buf_new(c_real_name);
2467 }
2468 }
2469
2470 if (!(((WithCrypto & APPLICATION_PGP) != 0) && (flags & SEND_KEY)))
2471 mutt_file_fclose(&fp_tmp);
2472
2473 if (!(flags & SEND_BATCH))
2474 {
2475 struct stat st = { 0 };
2476 time_t mtime;
2477 struct Body *b = e_templ->body;
2478 while (b->parts)
2479 b = b->parts;
2480 mtime = mutt_file_decrease_mtime(b->filename, NULL);
2481 if (mtime == (time_t) -1)
2482 {
2483 mutt_perror("%s", b->filename);
2484 goto cleanup;
2485 }
2486
2487 mutt_update_encoding(b, sub);
2488
2489 const bool c_edit_headers = cs_subset_bool(sub, "edit_headers");
2490 const bool c_auto_edit = cs_subset_bool(sub, "auto_edit");
2491
2492 /* Select whether or not the user's editor should be called now. We
2493 * don't want to do this when:
2494 * 1) we are sending a key/cert
2495 * 2) we are forwarding a message and the user doesn't want to edit it.
2496 * This is controlled by the quadoption $forward_edit. However, if
2497 * both $edit_headers and $auto_edit are set, we want to ignore the
2498 * setting of $forward_edit because the user probably needs to add the
2499 * recipients. */
2500 if (!(flags & SEND_KEY) &&
2501 (((flags & SEND_FORWARD) == 0) || (c_edit_headers && c_auto_edit) ||
2502 (query_quadoption(_("Edit forwarded message?"), sub, "forward_edit") == MUTT_YES)))
2503 {
2504 /* If the this isn't a text message, look for a mailcap edit command */
2505 const char *const c_editor = cs_subset_string(sub, "editor");
2506 b = e_templ->body;
2507 while (b->parts)
2508 b = b->parts;
2509 if (mutt_needs_mailcap(b))
2510 {
2511 if (!mutt_edit_attachment(b))
2512 goto cleanup;
2513 }
2514 else if (c_edit_headers)
2515 {
2516 mutt_env_to_local(e_templ->env);
2517 mutt_edit_headers(c_editor, b->filename, e_templ, &fcc);
2518 mutt_env_to_intl(e_templ->env, NULL, NULL);
2519 }
2520 else
2521 {
2522 mutt_edit_file(c_editor, b->filename);
2523 if (stat(b->filename, &st) == 0)
2524 {
2525 if (mtime != st.st_mtime)
2527 }
2528 else
2529 {
2530 mutt_perror("%s", b->filename);
2531 }
2532 }
2533
2534 mutt_message_hook(NULL, e_templ, MUTT_SEND2_HOOK);
2535 }
2536
2538 {
2539 if (stat(e_templ->body->filename, &st) == 0)
2540 {
2541 /* if the file was not modified, bail out now */
2542 if ((mtime == st.st_mtime) && !e_templ->body->next &&
2543 (query_quadoption(_("Abort unmodified message?"), sub, "abort_unmodified") == MUTT_YES))
2544 {
2545 mutt_message(_("Aborted unmodified message"));
2546 goto cleanup;
2547 }
2548 }
2549 else
2550 {
2551 mutt_perror("%s", e_templ->body->filename);
2552 }
2553 }
2554 }
2555
2556 /* Set the message security unless:
2557 * 1) crypto support is not enabled (WithCrypto==0)
2558 * 2) pgp: header field was present during message editing with $edit_headers (e_templ->security != 0)
2559 * 3) we are resending a message
2560 * 4) we are recalling a postponed message (don't override the user's saved settings)
2561 * 5) we are in batch mode
2562 * But 3, 4, and 5, can be overridden with '-C' in the command line (flags & SEND_CLI_CRYPTO)
2563 *
2564 * This is done after allowing the user to edit the message so that security
2565 * settings can be configured with send2-hook and $edit_headers. */
2566 if ((WithCrypto != 0) && (e_templ->security == 0) &&
2567 ((flags & SEND_CLI_CRYPTO) || !(flags & (SEND_BATCH | SEND_POSTPONED | SEND_RESEND))))
2568 {
2569 bool c_autocrypt = false;
2570 bool c_autocrypt_reply = false;
2571
2572#ifdef USE_AUTOCRYPT
2573 c_autocrypt = cs_subset_bool(sub, "autocrypt");
2574 c_autocrypt_reply = cs_subset_bool(sub, "autocrypt_reply");
2575#endif
2576
2577 if (c_autocrypt && c_autocrypt_reply && e_cur && (e_cur->security & SEC_AUTOCRYPT))
2578 {
2580 }
2581 else
2582 {
2583 const bool c_crypt_auto_sign = cs_subset_bool(sub, "crypt_auto_sign");
2584 const bool c_crypt_auto_encrypt = cs_subset_bool(sub, "crypt_auto_encrypt");
2585 const bool c_crypt_reply_encrypt = cs_subset_bool(sub, "crypt_reply_encrypt");
2586 const bool c_crypt_reply_sign = cs_subset_bool(sub, "crypt_reply_sign");
2587 const bool c_crypt_reply_sign_encrypted = cs_subset_bool(sub, "crypt_reply_sign_encrypted");
2588
2589 if (c_crypt_auto_sign)
2590 e_templ->security |= SEC_SIGN;
2591 if (c_crypt_auto_encrypt)
2592 e_templ->security |= SEC_ENCRYPT;
2593 if (c_crypt_reply_encrypt && e_cur && (e_cur->security & SEC_ENCRYPT))
2594 e_templ->security |= SEC_ENCRYPT;
2595 if (c_crypt_reply_sign && e_cur && (e_cur->security & SEC_SIGN))
2596 e_templ->security |= SEC_SIGN;
2597 if (c_crypt_reply_sign_encrypted && e_cur && (e_cur->security & SEC_ENCRYPT))
2598 e_templ->security |= SEC_SIGN;
2599
2600 const bool c_crypt_opportunistic_encrypt = cs_subset_bool(sub, "crypt_opportunistic_encrypt");
2601
2602 if (((WithCrypto & APPLICATION_PGP) != 0) &&
2603 ((e_templ->security & (SEC_ENCRYPT | SEC_SIGN)) || c_crypt_opportunistic_encrypt))
2604 {
2605 const bool c_pgp_auto_inline = cs_subset_bool(sub, "pgp_auto_inline");
2606 const bool c_pgp_reply_inline = cs_subset_bool(sub, "pgp_reply_inline");
2607
2608 if (c_pgp_auto_inline)
2609 e_templ->security |= SEC_INLINE;
2610 if (c_pgp_reply_inline && e_cur && (e_cur->security & SEC_INLINE))
2611 e_templ->security |= SEC_INLINE;
2612 }
2613 }
2614
2615 const bool c_crypt_opportunistic_encrypt = cs_subset_bool(sub, "crypt_opportunistic_encrypt");
2616
2617 if (e_templ->security || c_crypt_opportunistic_encrypt)
2618 {
2619 const bool c_crypt_auto_pgp = cs_subset_bool(sub, "crypt_auto_pgp");
2620 const bool c_crypt_auto_smime = cs_subset_bool(sub, "crypt_auto_smime");
2621
2622 /* When replying / forwarding, use the original message's
2623 * crypto system. According to the documentation,
2624 * smime_is_default should be disregarded here.
2625 *
2626 * Problem: At least with forwarding, this doesn't really
2627 * make much sense. Should we have an option to completely
2628 * disable individual mechanisms at run-time? */
2629 if (e_cur)
2630 {
2631 if (((WithCrypto & APPLICATION_PGP) != 0) && c_crypt_auto_pgp &&
2632 (e_cur->security & APPLICATION_PGP))
2633 {
2634 e_templ->security |= APPLICATION_PGP;
2635 }
2636 else if (((WithCrypto & APPLICATION_SMIME) != 0) &&
2637 c_crypt_auto_smime && (e_cur->security & APPLICATION_SMIME))
2638 {
2639 e_templ->security |= APPLICATION_SMIME;
2640 }
2641 }
2642
2643 const bool c_smime_is_default = cs_subset_bool(sub, "smime_is_default");
2644
2645 /* No crypto mechanism selected? Use availability + smime_is_default
2646 * for the decision. */
2647 if (!(e_templ->security & (APPLICATION_SMIME | APPLICATION_PGP)))
2648 {
2649 if (((WithCrypto & APPLICATION_SMIME) != 0) && c_crypt_auto_smime && c_smime_is_default)
2650 {
2651 e_templ->security |= APPLICATION_SMIME;
2652 }
2653 else if (((WithCrypto & APPLICATION_PGP) != 0) && c_crypt_auto_pgp)
2654 {
2655 e_templ->security |= APPLICATION_PGP;
2656 }
2657 else if (((WithCrypto & APPLICATION_SMIME) != 0) && c_crypt_auto_smime)
2658 {
2659 e_templ->security |= APPLICATION_SMIME;
2660 }
2661 }
2662 }
2663
2664 /* opportunistic encrypt relies on SMIME or PGP already being selected */
2665 if (c_crypt_opportunistic_encrypt)
2666 {
2667 /* If something has already enabled encryption, e.g. `$crypt_auto_encrypt`
2668 * or `$crypt_reply_encrypt`, then don't enable opportunistic encrypt for
2669 * the message. */
2670 if (!(e_templ->security & (SEC_ENCRYPT | SEC_AUTOCRYPT)))
2671 {
2672 e_templ->security |= SEC_OPPENCRYPT;
2674 }
2675 }
2676
2677 /* No permissible mechanisms found. Don't sign or encrypt. */
2678 if (!(e_templ->security & (APPLICATION_SMIME | APPLICATION_PGP)))
2679 e_templ->security = SEC_NO_FLAGS;
2680 }
2681
2682 /* Deal with the corner case where the crypto module backend is not available.
2683 * This can happen if configured without PGP/SMIME and with GPGME, but
2684 * $crypt_use_gpgme is unset. */
2685 if (e_templ->security && !crypt_has_module_backend(e_templ->security))
2686 {
2687 mutt_error(_("No crypto backend configured. Disabling message security setting."));
2688 e_templ->security = SEC_NO_FLAGS;
2689 }
2690
2691 /* specify a default fcc. if we are in batchmode, only save a copy of
2692 * the message if the value of $copy is yes or ask-yes */
2693
2694 const enum QuadOption c_copy = cs_subset_quad(sub, "copy");
2695
2696 if (buf_is_empty(&fcc) && !(flags & SEND_POSTPONED_FCC) &&
2697 (!(flags & SEND_BATCH) || (c_copy & 0x1)))
2698 {
2699 /* set the default FCC */
2700 const bool killfrom = TAILQ_EMPTY(&e_templ->env->from);
2701 if (killfrom)
2702 {
2704 }
2705 mutt_select_fcc(&fcc, e_templ);
2706 if (killfrom)
2707 {
2708 mutt_addrlist_clear(&e_templ->env->from);
2709 }
2710 }
2711
2712 mutt_rfc3676_space_stuff(e_templ);
2713
2714 mutt_update_encoding(e_templ->body, sub);
2715
2716 if (!(flags & SEND_BATCH))
2717 {
2718 main_loop:
2719
2720 buf_pretty_mailbox(&fcc);
2721 i = dlg_compose(e_templ, &fcc,
2722 ((flags & SEND_NO_FREE_HEADER) ? MUTT_COMPOSE_NOFREEHEADER : 0), sub);
2723 if (i == -1)
2724 {
2725 /* abort */
2726 if (flags & SEND_NEWS)
2727 mutt_message(_("Article not posted"));
2728 else
2729 mutt_message(_("Mail not sent"));
2730 goto cleanup;
2731 }
2732 else if (i == 1)
2733 {
2734 if (postpone_message(e_templ, e_cur, buf_string(&fcc), flags, sub) != 0)
2735 goto main_loop;
2736 mutt_message(_("Message postponed"));
2737 rc = 1;
2738 goto cleanup;
2739 }
2740 }
2741
2742 if (!(flags & SEND_NEWS))
2743 {
2744 if ((mutt_addrlist_count_recips(&e_templ->env->to) == 0) &&
2745 (mutt_addrlist_count_recips(&e_templ->env->cc) == 0) &&
2746 (mutt_addrlist_count_recips(&e_templ->env->bcc) == 0))
2747 {
2748 if (flags & SEND_BATCH)
2749 {
2750 puts(_("No recipients specified"));
2751 goto cleanup;
2752 }
2753
2754 mutt_warning(_("No recipients specified"));
2755 goto main_loop;
2756 }
2757 }
2758
2759 if (mutt_env_to_intl(e_templ->env, &tag, &err))
2760 {
2761 mutt_error(_("Bad IDN in '%s': '%s'"), tag, err);
2762 FREE(&err);
2763 if (flags & SEND_BATCH)
2764 goto cleanup;
2765 goto main_loop;
2766 }
2767
2768 const enum QuadOption c_abort_nosubject = cs_subset_quad(sub, "abort_nosubject");
2769
2770 if (!e_templ->env->subject && !(flags & SEND_BATCH) &&
2771 (query_quadoption(_("No subject, abort sending?"), sub, "abort_nosubject") != MUTT_NO))
2772 {
2773 /* if the abort is automatic, print an error message */
2774 if (c_abort_nosubject == MUTT_YES)
2775 mutt_error(_("No subject specified"));
2776 goto main_loop;
2777 }
2778
2779 if ((flags & SEND_NEWS) && !e_templ->env->subject)
2780 {
2781 mutt_error(_("No subject specified"));
2782 goto main_loop;
2783 }
2784
2785 if ((flags & SEND_NEWS) && !e_templ->env->newsgroups)
2786 {
2787 mutt_error(_("No newsgroup specified"));
2788 goto main_loop;
2789 }
2790
2791 if (!(flags & SEND_BATCH) && abort_for_missing_attachments(e_templ->body, sub))
2792 {
2793 goto main_loop;
2794 }
2795
2796 if (e_templ->body->next)
2797 e_templ->body = mutt_make_multipart(e_templ->body);
2798
2799 /* Ok, we need to do it this way instead of handling all fcc stuff in
2800 * one place in order to avoid going to main_loop with encoded "env"
2801 * in case of error. Ugh. */
2802
2803 mutt_encode_descriptions(e_templ->body, true, sub);
2804
2805 /* Make sure that clear_content and free_clear_content are
2806 * properly initialized -- we may visit this particular place in
2807 * the code multiple times, including after a failed call to
2808 * mutt_protect(). */
2809
2810 clear_content = NULL;
2811 free_clear_content = false;
2812
2813 if (WithCrypto)
2814 {
2815 if (e_templ->security & (SEC_ENCRYPT | SEC_SIGN | SEC_AUTOCRYPT))
2816 {
2817 /* save the decrypted attachments */
2818 clear_content = e_templ->body;
2819
2820 if ((crypt_get_keys(e_templ, &pgpkeylist, false) == -1) ||
2821 (mutt_protect(e_templ, pgpkeylist, false) == -1))
2822 {
2823 if (mutt_istr_equal(e_templ->body->subtype, "mixed"))
2824 e_templ->body = mutt_remove_multipart(e_templ->body);
2825
2826 FREE(&pgpkeylist);
2827
2828 decode_descriptions(e_templ->body);
2829
2830 if (flags & SEND_BATCH)
2831 {
2832 mutt_message(_("Missing encryption key; mail not sent"));
2833 rc = -1;
2834 goto cleanup;
2835 }
2836
2837 goto main_loop;
2838 }
2839 mutt_encode_descriptions(e_templ->body, false, sub);
2840 }
2841
2842 /* at this point, e_templ->body is one of the following three things:
2843 * - multipart/signed. In this case, clear_content is a child
2844 * - multipart/encrypted. In this case, clear_content exists independently
2845 * - application/pgp. In this case, clear_content exists independently
2846 * - something else. In this case, it's the same as clear_content */
2847
2848 /* This is ugly -- lack of "reporting back" from mutt_protect(). */
2849
2850 if (clear_content && (e_templ->body != clear_content) &&
2851 (e_templ->body->parts != clear_content))
2852 free_clear_content = true;
2853 }
2854
2855 if (!OptNoCurses)
2856 mutt_message(_("Sending message..."));
2857
2858 mutt_prepare_envelope(e_templ->env, true, sub);
2859
2860 const bool c_fcc_before_send = cs_subset_bool(sub, "fcc_before_send");
2861 if (c_fcc_before_send)
2862 save_fcc(m, e_templ, &fcc, clear_content, pgpkeylist, flags, &finalpath, sub);
2863
2864 i = invoke_mta(m, e_templ, sub);
2865 if (i < 0)
2866 {
2867 if (!(flags & SEND_BATCH))
2868 {
2869 if (!WithCrypto)
2870 ; // do nothing
2871 else if ((e_templ->security & (SEC_ENCRYPT | SEC_AUTOCRYPT)) ||
2872 ((e_templ->security & SEC_SIGN) && (e_templ->body->type == TYPE_APPLICATION)))
2873 {
2874 if (e_templ->body != clear_content)
2875 {
2876 mutt_body_free(&e_templ->body); /* destroy PGP data */
2877 e_templ->body = clear_content; /* restore clear text. */
2878 }
2879 }
2880 else if ((e_templ->security & SEC_SIGN) && (e_templ->body->type == TYPE_MULTIPART))
2881 {
2882 mutt_body_free(&e_templ->body->parts->next); /* destroy sig */
2883 if (mutt_istr_equal(e_templ->body->subtype, "mixed") ||
2884 mutt_istr_equal(e_templ->body->subtype, "signed"))
2885 {
2886 e_templ->body = mutt_remove_multipart(e_templ->body);
2887 }
2888 }
2889
2890 FREE(&pgpkeylist);
2891 mutt_env_free(&e_templ->body->mime_headers); /* protected headers */
2892 mutt_param_delete(&e_templ->body->parameter, "protected-headers");
2893 if (mutt_istr_equal(e_templ->body->subtype, "mixed"))
2894 e_templ->body = mutt_remove_multipart(e_templ->body);
2895 decode_descriptions(e_templ->body);
2896 mutt_unprepare_envelope(e_templ->env);
2897 FREE(&finalpath);
2898 goto main_loop;
2899 }
2900 else
2901 {
2902 puts(_("Could not send the message"));
2903 goto cleanup;
2904 }
2905 }
2906
2907 if (!c_fcc_before_send)
2908 save_fcc(m, e_templ, &fcc, clear_content, pgpkeylist, flags, &finalpath, sub);
2909
2910 if (!OptNoCurses)
2911 {
2912 mutt_message((i != 0) ? _("Sending in background") :
2913 (flags & SEND_NEWS) ? _("Article posted") :
2914 _("Mail sent"));
2915#ifdef USE_NOTMUCH
2916 const bool c_nm_record = cs_subset_bool(sub, "nm_record");
2917 if (c_nm_record)
2918 nm_record_message(m, finalpath, e_cur);
2919#endif
2920 mutt_sleep(0);
2921 }
2922
2923 if (WithCrypto)
2924 FREE(&pgpkeylist);
2925
2926 if ((WithCrypto != 0) && free_clear_content)
2927 mutt_body_free(&clear_content);
2928
2929 /* set 'replied' flag only if the user didn't change/remove
2930 * In-Reply-To: and References: headers during edit */
2931 if (flags & SEND_REPLY)
2932 {
2933 if (!(flags & SEND_POSTPONED) && m)
2934 {
2935 struct Email **ep = NULL;
2936 ARRAY_FOREACH(ep, ea)
2937 {
2938 struct Email *e = *ep;
2939 mutt_set_flag(m, e, MUTT_REPLIED, is_reply(e, e_templ), true);
2940 }
2941 }
2942 }
2943
2944 rc = 0;
2945
2946cleanup:
2947 buf_dealloc(&fcc);
2948
2949 if (flags & SEND_POSTPONED)
2950 {
2952 {
2953 cs_subset_str_string_set(sub, "pgp_sign_as", pgp_sign_as, NULL);
2954 FREE(&pgp_sign_as);
2955 }
2957 {
2958 cs_subset_str_string_set(sub, "smime_sign_as", smime_sign_as, NULL);
2959 FREE(&smime_sign_as);
2960 }
2961 }
2962
2963 mutt_file_fclose(&fp_tmp);
2964 if (!(flags & SEND_NO_FREE_HEADER))
2965 email_free(&e_templ);
2966
2967 FREE(&finalpath);
2968 return rc;
2969}
void mutt_addrlist_append(struct AddressList *al, struct Address *a)
Append an Address to an AddressList.
Definition: address.c:1484
int mutt_addrlist_count_recips(const struct AddressList *al)
Count the number of Addresses with valid recipients.
Definition: address.c:872
void mutt_expand_aliases_env(struct Envelope *env)
Expand aliases in all the fields of an Envelope.
Definition: alias.c:314
#define ARRAY_FOREACH(elem, head)
Iterate over all elements of the array.
Definition: array.h:212
#define ARRAY_SIZE(head)
The number of elements stored.
Definition: array.h:87
#define ARRAY_GET(head, idx)
Return the element at index.
Definition: array.h:109
void buf_dealloc(struct Buffer *buf)
Release the memory allocated by a buffer.
Definition: buffer.c:394
bool buf_is_empty(const struct Buffer *buf)
Is the Buffer empty?
Definition: buffer.c:308
struct Buffer buf_make(size_t size)
Make a new buffer on the stack.
Definition: buffer.c:75
struct Buffer * buf_new(const char *str)
Allocate a new Buffer.
Definition: buffer.c:321
char * buf_strdup(const struct Buffer *buf)
Copy a Buffer's string.
Definition: buffer.c:588
#define MUTT_COMPOSE_NOFREEHEADER
Definition: lib.h:50
enum QuadOption cs_subset_quad(const struct ConfigSubset *sub, const char *name)
Get a quad-value config item by name.
Definition: helpers.c:193
@ MUTT_NNTP
'NNTP' (Usenet) Mailbox type
Definition: mailbox.h:49
int mutt_protect(struct Email *e, char *keylist, bool postpone)
Encrypt and/or sign a message.
Definition: crypt.c:157
int crypt_get_keys(struct Email *e, char **keylist, bool oppenc_mode)
Check we have all the keys we need.
Definition: crypt.c:947
bool crypt_has_module_backend(SecurityFlags type)
Is there a crypto backend for a given type?
Definition: cryptglue.c:170
void mutt_edit_file(const char *editor, const char *file)
Let the user edit a file.
Definition: curs_lib.c:116
void mutt_body_free(struct Body **ptr)
Free a Body.
Definition: body.c:58
struct Body * mutt_body_new(void)
Create a new Body.
Definition: body.c:44
void mutt_parse_content_type(const char *s, struct Body *b)
Parse a content type.
Definition: parse.c:427
bool mutt_parse_mailto(struct Envelope *env, char **body, const char *src)
Parse a mailto:// url.
Definition: parse.c:1682
int mutt_env_to_intl(struct Envelope *env, const char **tag, char **err)
Convert an Envelope's Address fields to Punycode format.
Definition: envelope.c:355
void mutt_env_free(struct Envelope **ptr)
Free an Envelope.
Definition: envelope.c:126
struct Envelope * mutt_env_new(void)
Create a new Envelope.
Definition: envelope.c:46
void mutt_env_to_local(struct Envelope *env)
Convert an Envelope's Address fields to local format.
Definition: envelope.c:317
int mutt_file_copy_stream(FILE *fp_in, FILE *fp_out)
Copy the contents of one file into another.
Definition: file.c:282
time_t mutt_file_decrease_mtime(const char *fp, struct stat *st)
Decrease a file's modification time by 1 second.
Definition: file.c:1069
#define mutt_file_fclose(FP)
Definition: file.h:148
#define mutt_file_fopen(PATH, MODE)
Definition: file.h:147
void mutt_set_flag(struct Mailbox *m, struct Email *e, enum MessageType flag, bool bf, bool upd_mbox)
Set a flag on an email.
Definition: flags.c:57
bool OptNoCurses
(pseudo) when sending in batch mode
Definition: globals.c:72
int dlg_compose(struct Email *e, struct Buffer *fcc, uint8_t flags, struct ConfigSubset *sub)
Allow the user to edit the message envelope -.
Definition: dlg_compose.c:305
#define mutt_warning(...)
Definition: logging2.h:90
#define mutt_message(...)
Definition: logging2.h:91
#define mutt_debug(LEVEL,...)
Definition: logging2.h:89
#define mutt_perror(...)
Definition: logging2.h:93
void mutt_select_fcc(struct Buffer *path, struct Email *e)
Select the FCC path for an email.
Definition: hook.c:808
void mutt_message_hook(struct Mailbox *m, struct Email *e, HookFlags type)
Perform a message hook.
Definition: hook.c:692
#define MUTT_SEND_HOOK
send-hook: when composing a new email
Definition: hook.h:39
#define MUTT_SEND2_HOOK
send2-hook: when changing fields in the compose menu
Definition: hook.h:48
#define MUTT_REPLY_HOOK
reply-hook: when replying to an email
Definition: hook.h:47
@ LL_DEBUG5
Log at debug level 5.
Definition: logging2.h:47
@ LL_DEBUG1
Log at debug level 1.
Definition: logging2.h:43
@ TYPE_MULTIPART
Type: 'multipart/*'.
Definition: mime.h:37
@ TYPE_APPLICATION
Type: 'application/*'.
Definition: mime.h:33
@ DISP_INLINE
Content is inline.
Definition: mime.h:62
struct Body * mutt_remove_multipart(struct Body *b)
Extract the multipart body if it exists.
Definition: multipart.c:126
struct Body * mutt_make_multipart(struct Body *b)
Create a multipart email.
Definition: multipart.c:100
bool mutt_istr_equal(const char *a, const char *b)
Compare two strings, ignoring case.
Definition: string.c:721
@ MUTT_REPLIED
Messages that have been replied to.
Definition: mutt.h:72
bool mutt_edit_attachment(struct Body *b)
Edit an attachment.
Definition: mutt_attach.c:264
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:181
void mutt_sleep(short s)
Sleep for a while.
Definition: muttlib.c:878
void buf_pretty_mailbox(struct Buffer *buf)
Shorten a mailbox path using '~' or '='.
Definition: muttlib.c:554
bool mutt_needs_mailcap(struct Body *b)
Does this type need a mailcap entry do display.
Definition: muttlib.c:414
#define SEC_INLINE
Email has an inline signature.
Definition: lib.h:85
#define SEC_AUTOCRYPT
(Autocrypt) Message will be, or was Autocrypt encrypt+signed
Definition: lib.h:87
#define SEC_NO_FLAGS
No flags are set.
Definition: lib.h:77
#define SEC_ENCRYPT
Email is encrypted.
Definition: lib.h:78
#define SEC_AUTOCRYPT_OVERRIDE
(Autocrypt) Indicates manual set/unset of encryption
Definition: lib.h:88
#define SEC_SIGN
Email is signed.
Definition: lib.h:79
int nm_record_message(struct Mailbox *m, char *path, struct Email *e)
Add a message to the Notmuch database.
Definition: notmuch.c:1890
void mutt_param_delete(struct ParameterList *pl, const char *attribute)
Delete a matching Parameter.
Definition: parameter.c:143
void mutt_param_set(struct ParameterList *pl, const char *attribute, const char *value)
Set a Parameter.
Definition: parameter.c:111
int mutt_num_postponed(struct Mailbox *m, bool force)
Return the number of postponed messages.
Definition: postpone.c:70
int mutt_get_postponed(struct Mailbox *m_cur, struct Email *hdr, struct Email **cur, struct Buffer *fcc)
Recall a postponed message.
Definition: postpone.c:657
@ MUTT_NO
User answered 'No', or assume 'No'.
Definition: quad.h:38
void mutt_rfc3676_space_stuff(struct Email *e)
Perform RFC3676 space stuffing on an Email.
Definition: rfc3676.c:486
static int postpone_message(struct Email *e_post, struct Email *e_cur, const char *fcc, SendFlags flags, struct ConfigSubset *sub)
Save an Email for another day.
Definition: send.c:1943
static bool is_reply(struct Email *reply, struct Email *orig)
Is one email a reply to another?
Definition: send.c:1684
static int save_fcc(struct Mailbox *m, struct Email *e, struct Buffer *fcc, struct Body *clear_content, char *pgpkeylist, SendFlags flags, char **finalpath, struct ConfigSubset *sub)
Save an Email to a 'sent mail' folder.
Definition: send.c:1748
static int envelope_defaults(struct Envelope *env, struct EmailArray *ea, SendFlags flags, struct ConfigSubset *sub)
Fill in some defaults for a new email.
Definition: send.c:1154
void mutt_fix_reply_recipients(struct Envelope *env, struct ConfigSubset *sub)
Remove duplicate recipients.
Definition: send.c:1026
static int generate_body(FILE *fp_tmp, struct Email *e, SendFlags flags, struct Mailbox *m, struct EmailArray *ea, struct ConfigSubset *sub)
Create a new email body.
Definition: send.c:1227
static void mutt_make_greeting(struct Email *e, FILE *fp_out, struct ConfigSubset *sub)
Add greetings string.
Definition: send.c:753
static int invoke_mta(struct Mailbox *m, struct Email *e, struct ConfigSubset *sub)
Send an email.
Definition: send.c:1498
struct Address * mutt_default_from(struct ConfigSubset *sub)
Get a default 'from' Address.
Definition: send.c:1465
static void process_user_recips(struct Envelope *env)
Process the user headers.
Definition: send.c:378
static void process_user_header(struct Envelope *env)
Process the user headers.
Definition: send.c:403
static int edit_envelope(struct Envelope *en, SendFlags flags, struct ConfigSubset *sub)
Edit Envelope fields.
Definition: send.c:236
static bool abort_for_missing_attachments(const struct Body *b, struct ConfigSubset *sub)
Should we abort sending because of missing attachments?
Definition: send.c:2068
static void set_reverse_name(struct AddressList *al, struct Envelope *env, struct ConfigSubset *sub)
Try to set the 'from' field from the recipients.
Definition: send.c:1412
static void fix_end_of_file(const char *data)
Ensure a file ends with a linefeed.
Definition: send.c:1610
static bool is_text_plain(const struct Body *b)
Is a Body a text/plain MIME part?
Definition: send.c:2057
static void decode_descriptions(struct Body *b)
RFC2047 decode them in case of an error.
Definition: send.c:1593
static void append_signature(FILE *fp, struct ConfigSubset *sub)
Append a signature to an email.
Definition: send.c:110
#define SEND_POSTPONED_FCC
Used by mutt_get_postponed() to signal that the Mutt-Fcc header field was present.
Definition: send.h:50
#define SEND_BATCH
Send email in batch mode (without user interaction)
Definition: send.h:47
#define SEND_NO_FREE_HEADER
Used by the -E flag.
Definition: send.h:51
#define SEND_DRAFT_FILE
Used by the -H flag.
Definition: send.h:52
#define SEND_KEY
Mail a PGP public key.
Definition: send.h:48
#define SEND_POSTPONED
Recall a postponed email.
Definition: send.h:46
#define SEND_CONSUMED_STDIN
stdin has been read; don't read it twice
Definition: send.h:57
#define SEND_CLI_CRYPTO
Enable message security in modes that by default don't enable it.
Definition: send.h:58
#define SEND_REPLY
Reply to sender.
Definition: send.h:42
#define SEND_NEWS
Reply to a news article.
Definition: send.h:55
#define SEND_FORWARD
Forward email.
Definition: send.h:45
void mutt_update_encoding(struct Body *b, struct ConfigSubset *sub)
Update the encoding type.
Definition: sendlib.c:421
void mutt_unprepare_envelope(struct Envelope *env)
Undo the encodings of mutt_prepare_envelope()
Definition: sendlib.c:818
void mutt_prepare_envelope(struct Envelope *env, bool final, struct ConfigSubset *sub)
Prepare an email header.
Definition: sendlib.c:779
struct Buffer * personal
Real name of address.
Definition: address.h:37
struct Body * parts
parts of a multipart or message/rfc822
Definition: body.h:72
bool unlink
If true, filename should be unlink()ed before free()ing this structure.
Definition: body.h:67
struct Envelope * mime_headers
Memory hole protected headers.
Definition: body.h:75
struct ParameterList parameter
Parameters of the content-type.
Definition: body.h:62
bool use_disp
Content-Disposition uses filename= ?
Definition: body.h:47
unsigned int disposition
content-disposition, ContentDisposition
Definition: body.h:42
char * subtype
content-type subtype
Definition: body.h:60
unsigned int type
content-type primary type, ContentType
Definition: body.h:40
char * filename
When sending a message, this is the file to which this structure refers.
Definition: body.h:58
struct Envelope * env
Envelope information.
Definition: email.h:68
struct Body * body
List of MIME parts.
Definition: email.h:69
bool replied
Email has been replied to.
Definition: email.h:51
struct AddressList x_original_to
Email's 'X-Orig-to'.
Definition: envelope.h:66
char * newsgroups
List of newsgroups.
Definition: envelope.h:78
struct AddressList bcc
Email's 'Bcc' list.
Definition: envelope.h:62
char * list_post
This stores a mailto URL, or nothing.
Definition: envelope.h:67
enum MailboxType type
Mailbox type.
Definition: mailbox.h:102
void * mdata
Driver specific data.
Definition: mailbox.h:132
NNTP-specific Mailbox data -.
Definition: mdata.h:34
int cs_subset_str_string_set(const struct ConfigSubset *sub, const char *name, const char *value, struct Buffer *err)
Set a config item by string.
Definition: subset.c:386
#define buf_mktemp(buf)
Definition: tmp.h:33
+ Here is the caller graph for this function:

◆ mutt_set_followup_to()

void mutt_set_followup_to ( struct Envelope env,
struct ConfigSubset sub 
)

Set followup-to field.

Parameters
envEnvelope to modify
subConfig Subset

Definition at line 1341 of file send.c.

1342{
1343 /* Only generate the Mail-Followup-To if the user has requested it, and
1344 * it hasn't already been set */
1345
1346 const bool c_followup_to = cs_subset_bool(sub, "followup_to");
1347 if (!c_followup_to)
1348 return;
1349 if (OptNewsSend)
1350 {
1351 if (!env->followup_to && env->newsgroups && (strrchr(env->newsgroups, ',')))
1352 env->followup_to = mutt_str_dup(env->newsgroups);
1353 return;
1354 }
1355
1356 if (TAILQ_EMPTY(&env->mail_followup_to))
1357 {
1358 if (mutt_is_list_recipient(false, env))
1359 {
1360 /* this message goes to known mailing lists, so create a proper
1361 * mail-followup-to header */
1362
1363 mutt_addrlist_copy(&env->mail_followup_to, &env->to, false);
1364 mutt_addrlist_copy(&env->mail_followup_to, &env->cc, true);
1365 }
1366
1367 /* remove ourselves from the mail-followup-to header */
1368 remove_user(&env->mail_followup_to, false);
1369
1370 /* If we are not subscribed to any of the lists in question, re-add
1371 * ourselves to the mail-followup-to header. The mail-followup-to header
1372 * generated is a no-op with group-reply, but makes sure list-reply has the
1373 * desired effect. */
1374
1375 if (!TAILQ_EMPTY(&env->mail_followup_to) &&
1377 {
1378 struct AddressList *al = NULL;
1379 if (!TAILQ_EMPTY(&env->reply_to))
1380 al = &env->reply_to;
1381 else if (!TAILQ_EMPTY(&env->from))
1382 al = &env->from;
1383
1384 if (al)
1385 {
1386 struct Address *a = NULL;
1387 TAILQ_FOREACH_REVERSE(a, al, AddressList, entries)
1388 {
1390 }
1391 }
1392 else
1393 {
1395 }
1396 }
1397
1399 }
1400}
void mutt_addrlist_prepend(struct AddressList *al, struct Address *a)
Prepend an Address to an AddressList.
Definition: address.c:1495
bool mutt_is_subscribed_list_recipient(bool all_addr, struct Envelope *env)
Matches subscribed mailing lists.
Definition: exec.c:479
bool mutt_is_list_recipient(bool all_addr, struct Envelope *env)
Matches known mailing lists.
Definition: exec.c:492
#define TAILQ_FOREACH_REVERSE(var, head, headname, field)
Definition: queue.h:745
char * followup_to
List of 'followup-to' fields.
Definition: envelope.h:80
struct AddressList reply_to
Email's 'reply-to'.
Definition: envelope.h:64
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_send_list_subscribe()

bool mutt_send_list_subscribe ( struct Mailbox m,
struct Email e 
)

Send a mailing-list subscription email.

Parameters
mMailbox
eEmail carrying mailing-list subscription headers
Return values
trueSuccess
falseFailure

Definition at line 3032 of file send.c.

3033{
3034 if (!e || !e->env)
3035 {
3036 return false;
3037 }
3038
3039 const char *mailto = e->env->list_subscribe;
3040 if (!mailto)
3041 {
3042 mutt_warning(_("No List-Subscribe header found"));
3043 return false;
3044 }
3045
3046 struct EmailArray ea = ARRAY_HEAD_INITIALIZER;
3047 ARRAY_ADD(&ea, e);
3048 bool rc = send_simple_email(m, &ea, mailto, "Subscribe", "subscribe");
3049 ARRAY_FREE(&ea);
3050
3051 return rc;
3052}
static bool send_simple_email(struct Mailbox *m, struct EmailArray *ea, const char *mailto, const char *subj, const char *body)
Compose an email given a few basic ingredients.
Definition: send.c:2981
char * list_subscribe
This stores a mailto URL, or nothing.
Definition: envelope.h:68
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_send_list_unsubscribe()

bool mutt_send_list_unsubscribe ( struct Mailbox m,
struct Email e 
)

Send a mailing-list unsubscription email.

Parameters
mMailbox
eEmail carrying mailing-list unsubscription headers
Return values
trueSuccess
falseFailure

Definition at line 3061 of file send.c.

3062{
3063 if (!e || !e->env)
3064 {
3065 return false;
3066 }
3067
3068 const char *mailto = e->env->list_unsubscribe;
3069 if (!mailto)
3070 {
3071 mutt_warning(_("No List-Unsubscribe header found"));
3072 return false;
3073 }
3074
3075 struct EmailArray ea = ARRAY_HEAD_INITIALIZER;
3076 ARRAY_ADD(&ea, e);
3077 bool rc = send_simple_email(m, &ea, mailto, "Unsubscribe", "unsubscribe");
3078 ARRAY_FREE(&ea);
3079
3080 return rc;
3081}
char * list_unsubscribe
This stores a mailto URL, or nothing.
Definition: envelope.h:69
+ Here is the call graph for this function:
+ Here is the caller graph for this function: