NeoMutt  2024-02-01-25-ga71e95
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 1099 of file send.c.

1101{
1102 add_references(&env->references, env_cur);
1103 add_message_id(&env->references, env_cur);
1104 add_message_id(&env->in_reply_to, env_cur);
1105
1106 const bool c_x_comment_to = cs_subset_bool(sub, "x_comment_to");
1107 if (OptNewsSend && c_x_comment_to && !TAILQ_EMPTY(&env_cur->from))
1109}
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:1008
static void add_references(struct ListHead *head, struct Envelope *env)
Add the email's references to a list.
Definition: send.c:992
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 1460 of file send.c.

1461{
1462 /* Note: We let $from override $real_name here.
1463 * Is this the right thing to do?
1464 */
1465
1466 const struct Address *c_from = cs_subset_address(sub, "from");
1467 if (c_from)
1468 {
1469 return mutt_addr_copy(c_from);
1470 }
1471
1472 char domain[1024] = { 0 };
1473 const char *mailbox = Username;
1474 const bool c_use_domain = cs_subset_bool(sub, "use_domain");
1475 if (c_use_domain)
1476 {
1477 snprintf(domain, sizeof(domain), "%s@%s", NONULL(Username),
1478 NONULL(mutt_fqdn(true, sub)));
1479 mailbox = domain;
1480 }
1481
1482 return mutt_addr_create(NULL, mailbox);
1483}
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:264
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 190 of file send.c.

191{
192 int rc = 0;
193 struct Buffer *buf = buf_pool_get();
194 buf_alloc(buf, 8192);
195 char *err = NULL;
196 int idna_ok = 0;
197
198 do
199 {
201 buf_reset(buf);
202 mutt_addrlist_write(al, buf, false);
203 if (mw_get_field(field, buf, MUTT_COMP_NO_FLAGS, HC_ALIAS, &CompleteAliasOps, NULL) != 0)
204 {
205 rc = -1;
206 goto done;
207 }
210 if (expand_aliases)
212 idna_ok = mutt_addrlist_to_intl(al, &err);
213 if (idna_ok != 0)
214 {
215 mutt_error(_("Bad IDN: '%s'"), err);
216 FREE(&err);
217 }
218 } while (idna_ok != 0);
219
220done:
221 buf_pool_release(&buf);
222 return rc;
223}
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 1570 of file send.c.

1571{
1572 const struct Slist *const c_send_charset = cs_subset_slist(sub, "send_charset");
1573 for (struct Body *t = b; t; t = t->next)
1574 {
1575 if (t->description)
1576 {
1577 rfc2047_encode(&t->description, NULL, sizeof("Content-Description:"), c_send_charset);
1578 }
1579 if (recurse && t->parts)
1580 mutt_encode_descriptions(t->parts, recurse, sub);
1581 }
1582}
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:1570
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 933 of file send.c.

935{
936 enum QuadOption hmfupto = MUTT_ABORT;
937 const struct Address *followup_to = TAILQ_FIRST(&in->mail_followup_to);
938
939 if ((flags & (SEND_LIST_REPLY | SEND_GROUP_REPLY | SEND_GROUP_CHAT_REPLY)) && followup_to)
940 {
941 char prompt[256] = { 0 };
942 snprintf(prompt, sizeof(prompt), _("Follow-up to %s%s?"),
943 buf_string(followup_to->mailbox),
944 TAILQ_NEXT(TAILQ_FIRST(&in->mail_followup_to), entries) ? ",..." : "");
945
946 hmfupto = query_quadoption(prompt, sub, "honor_followup_to");
947 if (hmfupto == MUTT_ABORT)
948 return -1;
949 }
950
951 if (flags & SEND_LIST_REPLY)
952 {
953 add_mailing_lists(&out->to, &in->to, &in->cc);
954
955 if (followup_to && (hmfupto == MUTT_YES) &&
956 (default_to(&out->cc, in, flags & SEND_LIST_REPLY, (hmfupto == MUTT_YES), sub) == MUTT_ABORT))
957 {
958 return -1; /* abort */
959 }
960 }
961 else if (flags & SEND_TO_SENDER)
962 {
963 mutt_addrlist_copy(&out->to, &in->from, false);
964 }
965 else
966 {
967 if (default_to(&out->to, in, flags & (SEND_GROUP_REPLY | SEND_GROUP_CHAT_REPLY),
968 (hmfupto == MUTT_YES), sub) == -1)
969 {
970 return -1; /* abort */
971 }
972
973 if ((flags & (SEND_GROUP_REPLY | SEND_GROUP_CHAT_REPLY)) &&
974 (!followup_to || (hmfupto != MUTT_YES)))
975 {
976 /* if(!mutt_addr_is_user(in->to)) */
977 if (flags & SEND_GROUP_REPLY)
978 mutt_addrlist_copy(&out->cc, &in->to, true);
979 else
980 mutt_addrlist_copy(&out->to, &in->to, true);
981 mutt_addrlist_copy(&out->cc, &in->cc, true);
982 }
983 }
984 return 0;
985}
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:373
#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:163
static int default_to(struct AddressList *to, struct Envelope *env, SendFlags flags, int hmfupto, struct ConfigSubset *sub)
Generate default email addresses.
Definition: send.c:847
#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 1021 of file send.c.

1022{
1023 const bool c_me_too = cs_subset_bool(sub, "me_too");
1024 if (!c_me_too)
1025 {
1026 const bool c_reply_self = cs_subset_bool(sub, "reply_self");
1027
1028 /* the order is important here. do the CC: first so that if the
1029 * the user is the only recipient, it ends up on the TO: field */
1030 remove_user(&env->cc, TAILQ_EMPTY(&env->to));
1031 remove_user(&env->to, TAILQ_EMPTY(&env->cc) || c_reply_self);
1032 }
1033
1034 /* the CC field can get cluttered, especially with lists */
1035 mutt_addrlist_dedupe(&env->to);
1036 mutt_addrlist_dedupe(&env->cc);
1037 mutt_addrlist_remove_xrefs(&env->to, &env->cc);
1038
1039 if (!TAILQ_EMPTY(&env->cc) && TAILQ_EMPTY(&env->to))
1040 {
1041 TAILQ_SWAP(&env->to, &env->cc, Address, entries);
1042 }
1043}
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:144
+ 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 451 of file send.c.

452{
453 const char *const c_forward_attribution_intro = cs_subset_string(sub, "forward_attribution_intro");
454 if (!c_forward_attribution_intro || !fp)
455 return;
456
457 const char *const c_attribution_locale = cs_subset_string(sub, "attribution_locale");
458
459 struct Buffer *buf = buf_pool_get();
460 setlocale(LC_TIME, NONULL(c_attribution_locale));
461 mutt_make_string(buf, 0, c_forward_attribution_intro, NULL, -1, e,
463 setlocale(LC_TIME, "");
464 fputs(buf_string(buf), fp);
465 fputs("\n\n", fp);
466 buf_pool_release(&buf);
467}
const char * cs_subset_string(const struct ConfigSubset *sub, const char *name)
Get a string config item by name.
Definition: helpers.c:292
#define MUTT_FORMAT_NO_FLAGS
No flags are set.
Definition: format_flags.h:30
void mutt_make_string(struct Buffer *buf, int cols, const char *s, struct Mailbox *m, int inpgr, struct Email *e, MuttFormatFlags flags, const char *progress)
Create formatted strings using mailbox expandos.
Definition: hdrline.c:1438
+ 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 475 of file send.c.

476{
477 const char *const c_forward_attribution_trailer = cs_subset_string(sub, "forward_attribution_trailer");
478 if (!c_forward_attribution_trailer || !fp)
479 return;
480
481 const char *const c_attribution_locale = cs_subset_string(sub, "attribution_locale");
482
483 struct Buffer *buf = buf_pool_get();
484 setlocale(LC_TIME, NONULL(c_attribution_locale));
485 mutt_make_string(buf, 0, c_forward_attribution_trailer, NULL, -1, e,
487 setlocale(LC_TIME, "");
488 fputc('\n', fp);
489 fputs(buf_string(buf), fp);
490 fputc('\n', fp);
491 buf_pool_release(&buf);
492}
+ 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 659 of file send.c.

660{
661 format_attribution(cs_subset_string(sub, "attribution_intro"), e, fp_out, sub);
662}
static void format_attribution(const char *s, struct Email *e, FILE *fp_out, struct ConfigSubset *sub)
Format an attribution prefix/suffix.
Definition: send.c:636
+ 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 670 of file send.c.

671{
672 format_attribution(cs_subset_string(sub, "attribution_trailer"), e, fp_out, sub);
673}
+ 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 1051 of file send.c.

1052{
1053 if (!env)
1054 return;
1055
1056 const char *const c_forward_format = cs_subset_string(sub, "forward_format");
1057
1058 struct Buffer *buf = buf_pool_get();
1059 /* set the default subject for the message. */
1060 mutt_make_string(buf, 0, NONULL(c_forward_format), NULL, -1, e, MUTT_FORMAT_NO_FLAGS, NULL);
1062 buf_pool_release(&buf);
1063}
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 1071 of file send.c.

1073{
1074 if (!env || !env_cur)
1075 return;
1076
1077 /* This takes precedence over a subject that might have
1078 * been taken from a List-Post header. Is that correct? */
1079 if (env_cur->real_subj)
1080 {
1081 char *subj = NULL;
1082 mutt_str_asprintf(&subj, "Re: %s", env_cur->real_subj);
1083 mutt_env_set_subject(env, subj);
1084 FREE(&subj);
1085 }
1086 else if (!env->subject)
1087 {
1088 const char *const c_empty_subject = cs_subset_string(sub, "empty_subject");
1089 mutt_env_set_subject(env, c_empty_subject);
1090 }
1091}
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 1630 of file send.c.

1632{
1633 struct Email *e_new = email_new();
1634
1635 if (mutt_prepare_template(fp, m, e_new, e_cur, true) < 0)
1636 {
1637 email_free(&e_new);
1638 return -1;
1639 }
1640
1641 if (WithCrypto)
1642 {
1643 /* mutt_prepare_template doesn't always flip on an application bit.
1644 * so fix that here */
1645 if (!(e_new->security & (APPLICATION_SMIME | APPLICATION_PGP)))
1646 {
1647 const bool c_smime_is_default = cs_subset_bool(sub, "smime_is_default");
1648 if (((WithCrypto & APPLICATION_SMIME) != 0) && c_smime_is_default)
1649 e_new->security |= APPLICATION_SMIME;
1650 else if (WithCrypto & APPLICATION_PGP)
1651 e_new->security |= APPLICATION_PGP;
1652 else
1653 e_new->security |= APPLICATION_SMIME;
1654 }
1655
1656 const bool c_crypt_opportunistic_encrypt = cs_subset_bool(sub, "crypt_opportunistic_encrypt");
1657 if (c_crypt_opportunistic_encrypt)
1658 {
1659 e_new->security |= SEC_OPPENCRYPT;
1661 }
1662 }
1663
1664 struct EmailArray ea = ARRAY_HEAD_INITIALIZER;
1665 ARRAY_ADD(&ea, e_cur);
1666 int rc = mutt_send_message(SEND_RESEND, e_new, NULL, m, &ea, sub);
1667 ARRAY_FREE(&ea);
1668
1669 return rc;
1670}
#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:2115
#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 2115 of file send.c.

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

1337{
1338 /* Only generate the Mail-Followup-To if the user has requested it, and
1339 * it hasn't already been set */
1340
1341 const bool c_followup_to = cs_subset_bool(sub, "followup_to");
1342 if (!c_followup_to)
1343 return;
1344 if (OptNewsSend)
1345 {
1346 if (!env->followup_to && env->newsgroups && (strrchr(env->newsgroups, ',')))
1347 env->followup_to = mutt_str_dup(env->newsgroups);
1348 return;
1349 }
1350
1351 if (TAILQ_EMPTY(&env->mail_followup_to))
1352 {
1353 if (mutt_is_list_recipient(false, env))
1354 {
1355 /* this message goes to known mailing lists, so create a proper
1356 * mail-followup-to header */
1357
1358 mutt_addrlist_copy(&env->mail_followup_to, &env->to, false);
1359 mutt_addrlist_copy(&env->mail_followup_to, &env->cc, true);
1360 }
1361
1362 /* remove ourselves from the mail-followup-to header */
1363 remove_user(&env->mail_followup_to, false);
1364
1365 /* If we are not subscribed to any of the lists in question, re-add
1366 * ourselves to the mail-followup-to header. The mail-followup-to header
1367 * generated is a no-op with group-reply, but makes sure list-reply has the
1368 * desired effect. */
1369
1370 if (!TAILQ_EMPTY(&env->mail_followup_to) &&
1372 {
1373 struct AddressList *al = NULL;
1374 if (!TAILQ_EMPTY(&env->reply_to))
1375 al = &env->reply_to;
1376 else if (!TAILQ_EMPTY(&env->from))
1377 al = &env->from;
1378
1379 if (al)
1380 {
1381 struct Address *a = NULL;
1382 TAILQ_FOREACH_REVERSE(a, al, AddressList, entries)
1383 {
1385 }
1386 }
1387 else
1388 {
1390 }
1391 }
1392
1394 }
1395}
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 3027 of file send.c.

3028{
3029 if (!e || !e->env)
3030 {
3031 return false;
3032 }
3033
3034 const char *mailto = e->env->list_subscribe;
3035 if (!mailto)
3036 {
3037 mutt_warning(_("No List-Subscribe header found"));
3038 return false;
3039 }
3040
3041 struct EmailArray ea = ARRAY_HEAD_INITIALIZER;
3042 ARRAY_ADD(&ea, e);
3043 bool rc = send_simple_email(m, &ea, mailto, "Subscribe", "subscribe");
3044 ARRAY_FREE(&ea);
3045
3046 return rc;
3047}
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:2976
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 3056 of file send.c.

3057{
3058 if (!e || !e->env)
3059 {
3060 return false;
3061 }
3062
3063 const char *mailto = e->env->list_unsubscribe;
3064 if (!mailto)
3065 {
3066 mutt_warning(_("No List-Unsubscribe header found"));
3067 return false;
3068 }
3069
3070 struct EmailArray ea = ARRAY_HEAD_INITIALIZER;
3071 ARRAY_ADD(&ea, e);
3072 bool rc = send_simple_email(m, &ea, mailto, "Unsubscribe", "unsubscribe");
3073 ARRAY_FREE(&ea);
3074
3075 return rc;
3076}
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: