NeoMutt  2023-11-03-107-g582dc1
Teaching an old dog new tricks
DOXYGEN
Loading...
Searching...
No Matches
sendlib.h File Reference

Miscellaneous functions for sending an email. More...

#include <stdbool.h>
#include <stdio.h>
#include "email/lib.h"
+ Include dependency graph for sendlib.h:
+ This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros

#define MUTT_RANDTAG_LEN   16
 

Functions

int mutt_bounce_message (FILE *fp, struct Mailbox *m, struct Email *e, struct AddressList *to, struct ConfigSubset *sub)
 Bounce an email message.
 
const char * mutt_fqdn (bool may_hide_host, const struct ConfigSubset *sub)
 Get the Fully-Qualified Domain Name.
 
enum ContentType mutt_lookup_mime_type (struct Body *b, const char *path)
 Find the MIME type for an attachment.
 
struct Bodymutt_make_file_attach (const char *path, struct ConfigSubset *sub)
 Create a file attachment.
 
struct Bodymutt_make_message_attach (struct Mailbox *m, struct Email *e, bool attach_msg, struct ConfigSubset *sub)
 Create a message attachment.
 
void mutt_message_to_7bit (struct Body *b, FILE *fp, struct ConfigSubset *sub)
 Convert an email's MIME parts to 7-bit.
 
void mutt_prepare_envelope (struct Envelope *env, bool final, struct ConfigSubset *sub)
 Prepare an email header.
 
void mutt_stamp_attachment (struct Body *b)
 Timestamp an Attachment.
 
void mutt_unprepare_envelope (struct Envelope *env)
 Undo the encodings of mutt_prepare_envelope()
 
void mutt_update_encoding (struct Body *b, struct ConfigSubset *sub)
 Update the encoding type.
 
int mutt_write_fcc (const char *path, struct Email *e, const char *msgid, bool post, const char *fcc, char **finalpath, struct ConfigSubset *sub)
 Write email to FCC mailbox.
 
int mutt_write_multiple_fcc (const char *path, struct Email *e, const char *msgid, bool post, char *fcc, char **finalpath, struct ConfigSubset *sub)
 Handle FCC with multiple, comma separated entries.
 

Detailed Description

Miscellaneous functions for sending an email.

Authors
  • Richard Russon
  • Pietro Cerutti

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

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

Definition in file sendlib.h.

Macro Definition Documentation

◆ MUTT_RANDTAG_LEN

#define MUTT_RANDTAG_LEN   16

Definition at line 35 of file sendlib.h.

Function Documentation

◆ mutt_bounce_message()

int mutt_bounce_message ( FILE *  fp,
struct Mailbox m,
struct Email e,
struct AddressList *  to,
struct ConfigSubset sub 
)

Bounce an email message.

Parameters
fpHandle of message
mMailbox
eEmail
toAddressList to bounce to
subConfig Subset
Return values
0Success
-1Failure

Definition at line 915 of file sendlib.c.

917{
918 if (!fp || !e || !to || TAILQ_EMPTY(to))
919 return -1;
920
921 const char *fqdn = mutt_fqdn(true, sub);
922 char *err = NULL;
923
924 struct Address *from = mutt_default_from(sub);
925 struct AddressList from_list = TAILQ_HEAD_INITIALIZER(from_list);
926 mutt_addrlist_append(&from_list, from);
927
928 /* mutt_default_from() does not use $real_name if the real name is not set
929 * in $from, so we add it here. The reason it is not added in
930 * mutt_default_from() is that during normal sending, we execute
931 * send-hooks and set the real_name last so that it can be changed based
932 * upon message criteria. */
933 if (!from->personal)
934 {
935 const char *const c_real_name = cs_subset_string(sub, "real_name");
936 if (c_real_name)
937 from->personal = buf_new(c_real_name);
938 }
939
940 mutt_addrlist_qualify(&from_list, fqdn);
941
942 rfc2047_encode_addrlist(&from_list, "Resent-From");
943 if (mutt_addrlist_to_intl(&from_list, &err))
944 {
945 mutt_error(_("Bad IDN %s while preparing resent-from"), err);
946 FREE(&err);
947 mutt_addrlist_clear(&from_list);
948 return -1;
949 }
950 struct Buffer *resent_from = buf_pool_get();
951 mutt_addrlist_write(&from_list, resent_from, false);
952
953 OptNewsSend = false;
954
955 /* prepare recipient list. idna conversion appears to happen before this
956 * function is called, since the user receives confirmation of the address
957 * list being bounced to. */
958 struct AddressList resent_to = TAILQ_HEAD_INITIALIZER(resent_to);
959 mutt_addrlist_copy(&resent_to, to, false);
960 rfc2047_encode_addrlist(&resent_to, "Resent-To");
961 int rc = bounce_message(fp, m, e, &resent_to, buf_string(resent_from), &from_list, sub);
962 mutt_addrlist_clear(&resent_to);
963 mutt_addrlist_clear(&from_list);
964 buf_pool_release(&resent_from);
965 return rc;
966}
void mutt_addrlist_copy(struct AddressList *dst, const struct AddressList *src, bool prune)
Copy a list of addresses into another list.
Definition: address.c:762
void mutt_addrlist_qualify(struct AddressList *al, const char *host)
Expand local names in an Address list using a hostname.
Definition: address.c:677
void mutt_addrlist_clear(struct AddressList *al)
Unlink and free all Address in an AddressList.
Definition: address.c:1461
void mutt_addrlist_append(struct AddressList *al, struct Address *a)
Append an Address to an AddressList.
Definition: address.c:1481
size_t mutt_addrlist_write(const struct AddressList *al, struct Buffer *buf, bool display)
Write an Address to a buffer.
Definition: address.c:1207
int mutt_addrlist_to_intl(struct AddressList *al, char **err)
Convert an Address list to Punycode.
Definition: address.c:1294
struct Buffer * buf_new(const char *str)
Allocate a new Buffer.
Definition: buffer.c:316
static const char * buf_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:93
const char * cs_subset_string(const struct ConfigSubset *sub, const char *name)
Get a string config item by name.
Definition: helpers.c:292
bool OptNewsSend
(pseudo) used to change behavior when posting
Definition: globals.c:76
#define mutt_error(...)
Definition: logging2.h:92
#define FREE(x)
Definition: memory.h:45
#define _(a)
Definition: message.h:28
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
#define TAILQ_HEAD_INITIALIZER(head)
Definition: queue.h:637
#define TAILQ_EMPTY(head)
Definition: queue.h:721
void rfc2047_encode_addrlist(struct AddressList *al, const char *tag)
Encode any RFC2047 headers, where required, in an Address list.
Definition: rfc2047.c:762
struct Address * mutt_default_from(struct ConfigSubset *sub)
Get a default 'from' Address.
Definition: send.c:1444
const char * mutt_fqdn(bool may_hide_host, const struct ConfigSubset *sub)
Get the Fully-Qualified Domain Name.
Definition: sendlib.c:705
static int bounce_message(FILE *fp, struct Mailbox *m, struct Email *e, struct AddressList *to, const char *resent_from, struct AddressList *env_from, struct ConfigSubset *sub)
Bounce an email message.
Definition: sendlib.c:843
An email address.
Definition: address.h:36
struct Buffer * personal
Real name of address.
Definition: address.h:37
String manipulation buffer.
Definition: buffer.h:34
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_fqdn()

const char * mutt_fqdn ( bool  may_hide_host,
const struct ConfigSubset sub 
)

Get the Fully-Qualified Domain Name.

Parameters
may_hide_hostIf true, hide the hostname (leaving just the domain)
subConfig Subset
Return values
ptrstring pointer into Hostname
NULLError, e.g no Hostname
Warning
Do not free the returned pointer

Definition at line 705 of file sendlib.c.

706{
707 const char *const c_hostname = cs_subset_string(sub, "hostname");
708 if (!c_hostname || (c_hostname[0] == '@'))
709 return NULL;
710
711 const char *p = c_hostname;
712
713 const bool c_hidden_host = cs_subset_bool(sub, "hidden_host");
714 if (may_hide_host && c_hidden_host)
715 {
716 p = strchr(c_hostname, '.');
717 if (p)
718 p++;
719
720 // sanity check: don't hide the host if the fqdn is something like example.com
721 if (!p || !strchr(p, '.'))
722 p = c_hostname;
723 }
724
725 return p;
726}
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:48
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_lookup_mime_type()

enum ContentType mutt_lookup_mime_type ( struct Body b,
const char *  path 
)

Find the MIME type for an attachment.

Parameters
bEmail with attachment
pathPath to attachment
Return values
enumContentType, e.g. TYPE_IMAGE

Given a file at 'path', see if there is a registered MIME type. Returns the major MIME type, and copies the subtype to "d". First look in a system mime.types if we can find one, then look for ~/.mime.types. The longest match is used so that we can match 'ps.gz' when 'gz' also exists.

Definition at line 74 of file sendlib.c.

75{
76 FILE *fp = NULL;
77 char *p = NULL, *q = NULL, *ct = NULL;
78 char buf[PATH_MAX] = { 0 };
79 char subtype[256] = { 0 };
80 char xtype[256] = { 0 };
81 int sze, cur_sze = 0;
82 bool found_mimetypes = false;
83 enum ContentType type = TYPE_OTHER;
84
85 int szf = mutt_str_len(path);
86
87 for (int count = 0; count < 4; count++)
88 {
89 /* can't use strtok() because we use it in an inner loop below, so use
90 * a switch statement here instead. */
91 switch (count)
92 {
93 /* last file with last entry to match wins type/xtype */
94 case 0:
95 /* check default unix mimetypes location first */
96 mutt_str_copy(buf, "/etc/mime.types", sizeof(buf));
97 break;
98 case 1:
99 mutt_str_copy(buf, SYSCONFDIR "/mime.types", sizeof(buf));
100 break;
101 case 2:
102 mutt_str_copy(buf, PKGDATADIR "/mime.types", sizeof(buf));
103 break;
104 case 3:
105 snprintf(buf, sizeof(buf), "%s/.mime.types", NONULL(HomeDir));
106 break;
107 default:
108 mutt_debug(LL_DEBUG1, "Internal error, count = %d\n", count);
109 goto bye; /* shouldn't happen */
110 }
111
112 fp = fopen(buf, "r");
113 if (fp)
114 {
115 found_mimetypes = true;
116
117 while (fgets(buf, sizeof(buf) - 1, fp))
118 {
119 /* weed out any comments */
120 p = strchr(buf, '#');
121 if (p)
122 *p = '\0';
123
124 /* remove any leading space. */
125 ct = buf;
126 SKIPWS(ct);
127
128 /* position on the next field in this line */
129 p = strpbrk(ct, " \t");
130 if (!p)
131 continue;
132 *p++ = 0;
133 SKIPWS(p);
134
135 /* cycle through the file extensions */
136 while ((p = strtok(p, " \t\n")))
137 {
138 sze = mutt_str_len(p);
139 if ((sze > cur_sze) && (szf >= sze) && mutt_istr_equal(path + szf - sze, p) &&
140 ((szf == sze) || (path[szf - sze - 1] == '.')))
141 {
142 /* get the content-type */
143
144 p = strchr(ct, '/');
145 if (!p)
146 {
147 /* malformed line, just skip it. */
148 break;
149 }
150 *p++ = 0;
151
152 for (q = p; *q && !isspace(*q); q++)
153 ; // do nothing
154
155 mutt_strn_copy(subtype, p, q - p, sizeof(subtype));
156
157 type = mutt_check_mime_type(ct);
158 if (type == TYPE_OTHER)
159 mutt_str_copy(xtype, ct, sizeof(xtype));
160
161 cur_sze = sze;
162 }
163 p = NULL;
164 }
165 }
166 mutt_file_fclose(&fp);
167 }
168 }
169
170bye:
171
172 /* no mime.types file found */
173 if (!found_mimetypes)
174 {
175 mutt_error(_("Could not find any mime.types file"));
176 }
177
178 if ((type != TYPE_OTHER) || (*xtype != '\0'))
179 {
180 b->type = type;
181 mutt_str_replace(&b->subtype, subtype);
182 mutt_str_replace(&b->xtype, xtype);
183 }
184
185 return type;
186}
char * HomeDir
User's home directory.
Definition: globals.c:39
enum ContentType mutt_check_mime_type(const char *s)
Check a MIME type string.
Definition: parse.c:325
int mutt_file_fclose(FILE **fp)
Close a FILE handle (and NULL the pointer)
Definition: file.c:152
#define mutt_debug(LEVEL,...)
Definition: logging2.h:89
@ LL_DEBUG1
Log at debug level 1.
Definition: logging2.h:43
ContentType
Content-Type.
Definition: mime.h:30
@ TYPE_OTHER
Unknown Content-Type.
Definition: mime.h:31
bool mutt_istr_equal(const char *a, const char *b)
Compare two strings, ignoring case.
Definition: string.c:775
char * mutt_strn_copy(char *dest, const char *src, size_t len, size_t dsize)
Copy a sub-string into a buffer.
Definition: string.c:432
size_t mutt_str_len(const char *a)
Calculate the length of a string, safely.
Definition: string.c:568
size_t mutt_str_copy(char *dest, const char *src, size_t dsize)
Copy a string into a buffer (guaranteeing NUL-termination)
Definition: string.c:653
char * mutt_str_replace(char **p, const char *s)
Replace one string with another.
Definition: string.c:327
#define PATH_MAX
Definition: mutt.h:41
#define NONULL(x)
Definition: string2.h:37
#define SKIPWS(ch)
Definition: string2.h:45
char * xtype
content-type if x-unknown
Definition: body.h:61
char * subtype
content-type subtype
Definition: body.h:60
unsigned int type
content-type primary type, ContentType
Definition: body.h:40
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_make_file_attach()

struct Body * mutt_make_file_attach ( const char *  path,
struct ConfigSubset sub 
)

Create a file attachment.

Parameters
pathFile to attach
subConfig Subset
Return values
ptrNewly allocated Body
NULLError

Definition at line 605 of file sendlib.c.

606{
607 if (!path || (path[0] == '\0'))
608 return NULL;
609
610 struct Body *b = mutt_body_new();
611 b->filename = mutt_str_dup(path);
612
613 const char *const c_mime_type_query_command = cs_subset_string(sub, "mime_type_query_command");
614 const bool c_mime_type_query_first = cs_subset_bool(sub, "mime_type_query_first");
615
616 if (c_mime_type_query_command && c_mime_type_query_first)
617 run_mime_type_query(b, sub);
618
619 /* Attempt to determine the appropriate content-type based on the filename
620 * suffix. */
621 if (!b->subtype)
622 mutt_lookup_mime_type(b, path);
623
624 if (!b->subtype && c_mime_type_query_command && !c_mime_type_query_first)
625 {
626 run_mime_type_query(b, sub);
627 }
628
629 struct Content *info = mutt_get_content_info(path, b, sub);
630 if (!info)
631 {
632 mutt_body_free(&b);
633 return NULL;
634 }
635
636 if (!b->subtype)
637 {
638 if ((info->nulbin == 0) &&
639 ((info->lobin == 0) || ((info->lobin + info->hibin + info->ascii) / info->lobin >= 10)))
640 {
641 /* Statistically speaking, there should be more than 10% "lobin"
642 * chars if this is really a binary file... */
643 b->type = TYPE_TEXT;
644 b->subtype = mutt_str_dup("plain");
645 }
646 else
647 {
649 b->subtype = mutt_str_dup("octet-stream");
650 }
651 }
652
653 FREE(&info);
654 mutt_update_encoding(b, sub);
655 return b;
656}
struct Content * mutt_get_content_info(const char *fname, struct Body *b, struct ConfigSubset *sub)
Analyze file to determine MIME encoding to use.
Definition: content_info.c:187
void mutt_body_free(struct Body **ptr)
Free a Body.
Definition: body.c:57
struct Body * mutt_body_new(void)
Create a new Body.
Definition: body.c:43
@ TYPE_APPLICATION
Type: 'application/*'.
Definition: mime.h:33
@ TYPE_TEXT
Type: 'text/*'.
Definition: mime.h:38
char * mutt_str_dup(const char *str)
Copy a string, safely.
Definition: string.c:251
void mutt_update_encoding(struct Body *b, struct ConfigSubset *sub)
Update the encoding type.
Definition: sendlib.c:420
enum ContentType mutt_lookup_mime_type(struct Body *b, const char *path)
Find the MIME type for an attachment.
Definition: sendlib.c:74
static void run_mime_type_query(struct Body *b, struct ConfigSubset *sub)
Run an external command to determine the MIME type.
Definition: sendlib.c:564
The body of an email.
Definition: body.h:36
char * filename
When sending a message, this is the file to which this structure refers.
Definition: body.h:58
Info about an attachment.
Definition: content.h:35
long hibin
8-bit characters
Definition: content.h:36
long ascii
Number of ascii chars.
Definition: content.h:40
long nulbin
Null characters (0x0)
Definition: content.h:38
long lobin
Unprintable 7-bit chars (eg., control chars)
Definition: content.h:37
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_make_message_attach()

struct Body * mutt_make_message_attach ( struct Mailbox m,
struct Email e,
bool  attach_msg,
struct ConfigSubset sub 
)

Create a message attachment.

Parameters
mMailbox
eEmail
attach_msgtrue if attaching a message
subConfig Subset
Return values
ptrNewly allocated Body
NULLError

Definition at line 452 of file sendlib.c.

454{
455 struct Body *body = NULL;
456 FILE *fp = NULL;
457 CopyMessageFlags cmflags;
459
460 const bool c_mime_forward_decode = cs_subset_bool(sub, "mime_forward_decode");
461 const bool c_forward_decrypt = cs_subset_bool(sub, "forward_decrypt");
462 if (WithCrypto)
463 {
464 if ((c_mime_forward_decode || c_forward_decrypt) && (e->security & SEC_ENCRYPT))
465 {
467 return NULL;
468 }
469 }
470
471 struct Buffer *buf = buf_pool_get();
472 buf_mktemp(buf);
473 fp = mutt_file_fopen(buf_string(buf), "w+");
474 if (!fp)
475 {
476 buf_pool_release(&buf);
477 return NULL;
478 }
479
480 body = mutt_body_new();
481 body->type = TYPE_MESSAGE;
482 body->subtype = mutt_str_dup("rfc822");
483 body->filename = mutt_str_dup(buf_string(buf));
484 body->unlink = true;
485 body->use_disp = false;
486 body->disposition = DISP_INLINE;
487 body->noconv = true;
488
489 buf_pool_release(&buf);
490
491 struct Message *msg = mx_msg_open(m, e);
492 if (!msg)
493 {
494 mutt_body_free(&body);
496 return NULL;
497 }
499
500 CopyHeaderFlags chflags = CH_XMIT;
501 cmflags = MUTT_CM_NO_FLAGS;
502
503 /* If we are attaching a message, ignore `$mime_forward_decode` */
504 if (!attach_msg && c_mime_forward_decode)
505 {
506 chflags |= CH_MIME | CH_TXTPLAIN;
509 pgp &= ~PGP_ENCRYPT;
511 pgp &= ~SMIME_ENCRYPT;
512 }
513 else if ((WithCrypto != 0) && c_forward_decrypt && (e->security & SEC_ENCRYPT))
514 {
516 {
517 chflags |= CH_MIME | CH_NONEWLINE;
518 cmflags = MUTT_CM_DECODE_PGP;
519 pgp &= ~PGP_ENCRYPT;
520 }
521 else if (((WithCrypto & APPLICATION_PGP) != 0) &&
523 {
524 chflags |= CH_MIME | CH_TXTPLAIN;
526 pgp &= ~PGP_ENCRYPT;
527 }
528 else if (((WithCrypto & APPLICATION_SMIME) != 0) &&
530 {
531 chflags |= CH_MIME | CH_TXTPLAIN;
533 pgp &= ~SMIME_ENCRYPT;
534 }
535 }
536
537 mutt_copy_message(fp, e, msg, cmflags, chflags, 0);
538 mx_msg_close(m, &msg);
539
540 fflush(fp);
541 rewind(fp);
542
543 body->email = email_new();
544 body->email->offset = 0;
545 /* we don't need the user headers here */
546 body->email->env = mutt_rfc822_read_header(fp, body->email, false, false);
547 if (WithCrypto)
548 body->email->security = pgp;
549 mutt_update_encoding(body, sub);
550 body->parts = body->email->body;
551
553
554 return body;
555}
void mutt_parse_mime_message(struct Email *e, FILE *fp)
Parse a MIME email.
Definition: attachments.c:596
int mutt_copy_message(FILE *fp_out, struct Email *e, struct Message *msg, CopyMessageFlags cmflags, CopyHeaderFlags chflags, int wraplen)
Copy a message from a Mailbox.
Definition: copy.c:884
#define CH_XMIT
Transmitting this message? (Ignore Lines: and Content-Length:)
Definition: copy.h:55
#define MUTT_CM_DECODE_PGP
Used for decoding PGP messages.
Definition: copy.h:45
#define MUTT_CM_DECODE
Decode the message body into text/plain.
Definition: copy.h:38
#define CH_NONEWLINE
Don't output terminating newline after the header.
Definition: copy.h:60
#define MUTT_CM_CHARCONV
Perform character set conversions.
Definition: copy.h:42
#define CH_MIME
Ignore MIME fields.
Definition: copy.h:61
uint32_t CopyHeaderFlags
Flags for mutt_copy_header(), e.g. CH_UPDATE.
Definition: copy.h:50
#define MUTT_CM_NO_FLAGS
No flags are set.
Definition: copy.h:35
#define CH_TXTPLAIN
Generate text/plain MIME headers.
Definition: copy.h:63
uint16_t CopyMessageFlags
Flags for mutt_copy_message(), e.g. MUTT_CM_NOHEADER.
Definition: copy.h:34
SecurityFlags mutt_is_application_pgp(struct Body *b)
Does the message use PGP?
Definition: crypt.c:537
SecurityFlags mutt_is_application_smime(struct Body *b)
Does the message use S/MIME?
Definition: crypt.c:598
bool crypt_valid_passphrase(SecurityFlags flags)
Check that we have a usable passphrase, ask if not.
Definition: crypt.c:135
SecurityFlags mutt_is_multipart_encrypted(struct Body *b)
Does the message have encrypted parts?
Definition: crypt.c:432
struct Email * email_new(void)
Create a new Email.
Definition: email.c:78
struct Envelope * mutt_rfc822_read_header(FILE *fp, struct Email *e, bool user_hdrs, bool weed)
Parses an RFC822 header.
Definition: parse.c:1156
FILE * mutt_file_fopen(const char *path, const char *mode)
Call fopen() safely.
Definition: file.c:636
@ TYPE_MESSAGE
Type: 'message/*'.
Definition: mime.h:35
@ DISP_INLINE
Content is inline.
Definition: mime.h:62
int mx_msg_close(struct Mailbox *m, struct Message **ptr)
Close a message.
Definition: mx.c:1185
struct Message * mx_msg_open(struct Mailbox *m, struct Email *e)
Return a stream pointer for a message.
Definition: mx.c:1139
uint16_t SecurityFlags
Flags, e.g. SEC_ENCRYPT.
Definition: lib.h:77
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: lib.h:91
#define PGP_ENCRYPT
Definition: lib.h:97
#define APPLICATION_SMIME
Use SMIME to encrypt/sign.
Definition: lib.h:92
#define SEC_NO_FLAGS
No flags are set.
Definition: lib.h:78
#define SEC_ENCRYPT
Email is encrypted.
Definition: lib.h:79
#define SMIME_ENCRYPT
Definition: lib.h:103
#define WithCrypto
Definition: lib.h:117
struct Body * parts
parts of a multipart or message/rfc822
Definition: body.h:72
bool noconv
Don't do character set conversion.
Definition: body.h:46
bool unlink
If true, filename should be unlink()ed before free()ing this structure.
Definition: body.h:67
bool use_disp
Content-Disposition uses filename= ?
Definition: body.h:47
struct Email * email
header information for message/rfc822
Definition: body.h:73
unsigned int disposition
content-disposition, ContentDisposition
Definition: body.h:42
struct Envelope * env
Envelope information.
Definition: email.h:66
SecurityFlags security
bit 0-10: flags, bit 11,12: application, bit 13: traditional pgp See: ncrypt/lib.h pgplib....
Definition: email.h:41
struct Body * body
List of MIME parts.
Definition: email.h:67
LOFF_T offset
Where in the stream does this message begin?
Definition: email.h:69
A local copy of an email.
Definition: message.h:34
FILE * fp
pointer to the message data
Definition: message.h:35
#define buf_mktemp(buf)
Definition: tmp.h:33
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_message_to_7bit()

void mutt_message_to_7bit ( struct Body b,
FILE *  fp,
struct ConfigSubset sub 
)

Convert an email's MIME parts to 7-bit.

Parameters
bBody of the email
fpFile to read (OPTIONAL)
subConfig Subset

Definition at line 257 of file sendlib.c.

258{
259 struct Buffer temp = buf_make(0);
260 FILE *fp_in = NULL;
261 FILE *fp_out = NULL;
262 struct stat st = { 0 };
263
264 if (!b->filename && fp)
265 {
266 fp_in = fp;
267 }
268 else if (!b->filename || !(fp_in = fopen(b->filename, "r")))
269 {
270 mutt_error(_("Could not open %s"), b->filename ? b->filename : "(null)");
271 return;
272 }
273 else
274 {
275 b->offset = 0;
276 if (stat(b->filename, &st) == -1)
277 {
278 mutt_perror("stat");
279 mutt_file_fclose(&fp_in);
280 goto cleanup;
281 }
282 b->length = st.st_size;
283 }
284
285 /* Avoid buffer pool due to recursion */
286 buf_mktemp(&temp);
287 fp_out = mutt_file_fopen(buf_string(&temp), "w+");
288 if (!fp_out)
289 {
290 mutt_perror("fopen");
291 goto cleanup;
292 }
293
294 if (!mutt_file_seek(fp_in, b->offset, SEEK_SET))
295 {
296 goto cleanup;
297 }
298 b->parts = mutt_rfc822_parse_message(fp_in, b);
299
300 transform_to_7bit(b->parts, fp_in, sub);
301
302 mutt_copy_hdr(fp_in, fp_out, b->offset, b->offset + b->length,
303 CH_MIME | CH_NONEWLINE | CH_XMIT, NULL, 0);
304
305 fputs("MIME-Version: 1.0\n", fp_out);
306 mutt_write_mime_header(b->parts, fp_out, sub);
307 fputc('\n', fp_out);
308 mutt_write_mime_body(b->parts, fp_out, sub);
309
310 if (fp_in != fp)
311 mutt_file_fclose(&fp_in);
312 mutt_file_fclose(&fp_out);
313
314 b->encoding = ENC_7BIT;
315 FREE(&b->d_filename);
316 b->d_filename = b->filename;
317 if (b->filename && b->unlink)
318 unlink(b->filename);
319 b->filename = buf_strdup(&temp);
320 b->unlink = true;
321 if (stat(b->filename, &st) == -1)
322 {
323 mutt_perror("stat");
324 goto cleanup;
325 }
326 b->length = st.st_size;
328 b->email->body = NULL;
329
330cleanup:
331 if (fp_in && (fp_in != fp))
332 mutt_file_fclose(&fp_in);
333
334 if (fp_out)
335 {
336 mutt_file_fclose(&fp_out);
338 }
339
340 buf_dealloc(&temp);
341}
void buf_dealloc(struct Buffer *buf)
Release the memory allocated by a buffer.
Definition: buffer.c:389
struct Buffer buf_make(size_t size)
Make a new buffer on the stack.
Definition: buffer.c:70
char * buf_strdup(const struct Buffer *buf)
Copy a Buffer's string.
Definition: buffer.c:542
int mutt_copy_hdr(FILE *fp_in, FILE *fp_out, LOFF_T off_start, LOFF_T off_end, CopyHeaderFlags chflags, const char *prefix, int wraplen)
Copy header from one file to another.
Definition: copy.c:106
struct Body * mutt_rfc822_parse_message(FILE *fp, struct Body *b)
Parse a Message/RFC822 body.
Definition: parse.c:1775
bool mutt_file_seek(FILE *fp, LOFF_T offset, int whence)
Wrapper for fseeko with error handling.
Definition: file.c:733
void mutt_file_unlink(const char *s)
Delete a file, carefully.
Definition: file.c:196
#define mutt_perror(...)
Definition: logging2.h:93
int mutt_write_mime_header(struct Body *b, FILE *fp, struct ConfigSubset *sub)
Create a MIME header.
Definition: header.c:754
@ ENC_7BIT
7-bit text
Definition: mime.h:49
int mutt_write_mime_body(struct Body *b, FILE *fp, struct ConfigSubset *sub)
Write a MIME part.
Definition: body.c:301
static void transform_to_7bit(struct Body *b, FILE *fp_in, struct ConfigSubset *sub)
Convert MIME parts to 7-bit.
Definition: sendlib.c:194
char * d_filename
filename to be used for the content-disposition header If NULL, filename is used instead.
Definition: body.h:56
LOFF_T offset
offset where the actual data begins
Definition: body.h:52
LOFF_T length
length (in bytes) of attachment
Definition: body.h:53
unsigned int encoding
content-transfer-encoding, ContentEncoding
Definition: body.h:41
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_prepare_envelope()

void mutt_prepare_envelope ( struct Envelope env,
bool  final,
struct ConfigSubset sub 
)

Prepare an email header.

Parameters
envEnvelope to prepare
finaltrue if this email is going to be sent (not postponed)
subConfig Subset

Encode all the headers prior to sending the email.

For postponing (!final) do the necessary encodings only

Definition at line 778 of file sendlib.c.

779{
780 if (final)
781 {
782 if (!TAILQ_EMPTY(&env->bcc) && TAILQ_EMPTY(&env->to) && TAILQ_EMPTY(&env->cc))
783 {
784 /* some MTA's will put an Apparently-To: header field showing the Bcc:
785 * recipients if there is no To: or Cc: field, so attempt to suppress
786 * it by using an empty To: field. */
787 struct Address *to = mutt_addr_new();
788 to->group = true;
789 mutt_addrlist_append(&env->to, to);
791
792 char buf[1024] = { 0 };
793 buf[0] = '\0';
794 mutt_addr_cat(buf, sizeof(buf), "undisclosed-recipients", AddressSpecials);
795
796 buf_strcpy(to->mailbox, buf);
797 }
798
799 mutt_set_followup_to(env, sub);
800
801 if (!env->message_id)
802 env->message_id = gen_msgid();
803 }
804
805 /* Take care of 8-bit => 7-bit conversion. */
807 encode_headers(&env->userhdrs, sub);
808}
void mutt_addr_cat(char *buf, size_t buflen, const char *value, const char *specials)
Copy a string and wrap it in quotes if it contains special characters.
Definition: address.c:705
struct Address * mutt_addr_new(void)
Create a new Address.
Definition: address.c:399
const char AddressSpecials[]
Characters with special meaning for email addresses.
Definition: address.c:43
size_t buf_strcpy(struct Buffer *buf, const char *s)
Copy a string into a Buffer.
Definition: buffer.c:407
void rfc2047_encode_envelope(struct Envelope *env)
Encode the fields of an Envelope.
Definition: rfc2047.c:848
void mutt_set_followup_to(struct Envelope *env, struct ConfigSubset *sub)
Set followup-to field.
Definition: send.c:1320
static char * gen_msgid(void)
Generate a random Message ID.
Definition: sendlib.c:751
static void encode_headers(struct ListHead *h, struct ConfigSubset *sub)
RFC2047-encode a list of headers.
Definition: sendlib.c:665
bool group
Group mailbox?
Definition: address.h:39
struct Buffer * mailbox
Mailbox and host address.
Definition: address.h:38
struct ListHead userhdrs
user defined headers
Definition: envelope.h:85
struct AddressList to
Email's 'To' list.
Definition: envelope.h:60
char * message_id
Message ID.
Definition: envelope.h:73
struct AddressList cc
Email's 'Cc' list.
Definition: envelope.h:61
struct AddressList bcc
Email's 'Bcc' list.
Definition: envelope.h:62
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_stamp_attachment()

void mutt_stamp_attachment ( struct Body b)

Timestamp an Attachment.

Parameters
bAttachment

Definition at line 408 of file sendlib.c.

409{
410 b->stamp = mutt_date_now();
411}
time_t mutt_date_now(void)
Return the number of seconds since the Unix epoch.
Definition: date.c:446
time_t stamp
Time stamp of last encoding update.
Definition: body.h:76
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_unprepare_envelope()

void mutt_unprepare_envelope ( struct Envelope env)

Undo the encodings of mutt_prepare_envelope()

Parameters
envEnvelope to unprepare

Decode all the headers of an email, e.g. when the sending failed or was aborted.

Definition at line 817 of file sendlib.c.

818{
819 struct ListNode *item = NULL;
820 STAILQ_FOREACH(item, &env->userhdrs, entries)
821 {
822 rfc2047_decode(&item->data);
823 }
824
826
827 /* back conversions */
829}
#define STAILQ_FOREACH(var, head, field)
Definition: queue.h:352
void rfc2047_decode_envelope(struct Envelope *env)
Decode the fields of an Envelope.
Definition: rfc2047.c:828
void rfc2047_decode(char **pd)
Decode any RFC2047-encoded header fields.
Definition: rfc2047.c:659
struct AddressList mail_followup_to
Email's 'mail-followup-to'.
Definition: envelope.h:65
A List node for strings.
Definition: list.h:35
char * data
String.
Definition: list.h:36
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_update_encoding()

void mutt_update_encoding ( struct Body b,
struct ConfigSubset sub 
)

Update the encoding type.

Parameters
bBody to update
subConfig Subset

Assumes called from send mode where Body->filename points to actual file

Definition at line 420 of file sendlib.c.

421{
422 struct Content *info = NULL;
423 char chsbuf[256] = { 0 };
424
425 /* override noconv when it's us-ascii */
426 if (mutt_ch_is_us_ascii(mutt_body_get_charset(b, chsbuf, sizeof(chsbuf))))
427 b->noconv = false;
428
429 if (!b->force_charset && !b->noconv)
430 mutt_param_delete(&b->parameter, "charset");
431
432 info = mutt_get_content_info(b->filename, b, sub);
433 if (!info)
434 return;
435
436 set_encoding(b, info, sub);
438
439 FREE(&b->content);
440 b->content = info;
441}
char * mutt_body_get_charset(struct Body *b, char *buf, size_t buflen)
Get a body's character set.
Definition: body.c:131
#define mutt_ch_is_us_ascii(str)
Definition: charset.h:97
void mutt_param_delete(struct ParameterList *pl, const char *attribute)
Delete a matching Parameter.
Definition: parameter.c:142
static void set_encoding(struct Body *b, struct Content *info, struct ConfigSubset *sub)
Determine which Content-Transfer-Encoding to use.
Definition: sendlib.c:349
void mutt_stamp_attachment(struct Body *b)
Timestamp an Attachment.
Definition: sendlib.c:408
struct ParameterList parameter
Parameters of the content-type.
Definition: body.h:62
struct Content * content
Detailed info about the content of the attachment.
Definition: body.h:69
bool force_charset
Send mode: don't adjust the character set when in send-mode.
Definition: body.h:44
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_write_fcc()

int mutt_write_fcc ( const char *  path,
struct Email e,
const char *  msgid,
bool  post,
const char *  fcc,
char **  finalpath,
struct ConfigSubset sub 
)

Write email to FCC mailbox.

Parameters
[in]pathPath to mailbox
[in]eEmail
[in]msgidMessage id
[in]postIf true, postpone message, else fcc mode
[in]fccfcc setting to save (postpone only)
[out]finalpathFinal path of email
[in]subConfig Subset
Return values
0Success
-1Failure

Definition at line 1051 of file sendlib.c.

1053{
1054 struct Message *msg = NULL;
1055 struct Buffer *tempfile = NULL;
1056 FILE *fp_tmp = NULL;
1057 int rc = -1;
1058 bool need_mailbox_cleanup = false;
1059 struct stat st = { 0 };
1060 MsgOpenFlags onm_flags;
1061
1062 if (post)
1063 set_noconv_flags(e->body, true);
1064
1065#ifdef RECORD_FOLDER_HOOK
1066 mutt_folder_hook(path, NULL);
1067#endif
1068 struct Mailbox *m_fcc = mx_path_resolve(path);
1069 bool old_append = m_fcc->append;
1070 if (!mx_mbox_open(m_fcc, MUTT_APPEND | MUTT_QUIET))
1071 {
1072 mutt_debug(LL_DEBUG1, "unable to open mailbox %s in append-mode, aborting\n", path);
1073 goto done;
1074 }
1075
1076 /* We need to add a Content-Length field to avoid problems where a line in
1077 * the message body begins with "From " */
1078 if ((m_fcc->type == MUTT_MMDF) || (m_fcc->type == MUTT_MBOX))
1079 {
1080 tempfile = buf_pool_get();
1081 buf_mktemp(tempfile);
1082 fp_tmp = mutt_file_fopen(buf_string(tempfile), "w+");
1083 if (!fp_tmp)
1084 {
1085 mutt_perror("%s", buf_string(tempfile));
1086 mx_mbox_close(m_fcc);
1087 goto done;
1088 }
1089 /* remember new mail status before appending message */
1090 need_mailbox_cleanup = true;
1091 stat(path, &st);
1092 }
1093
1094 e->read = !post; /* make sure to put it in the 'cur' directory (maildir) */
1095 onm_flags = MUTT_ADD_FROM;
1096 if (post)
1097 onm_flags |= MUTT_SET_DRAFT;
1098 msg = mx_msg_open_new(m_fcc, e, onm_flags);
1099 if (!msg)
1100 {
1101 mutt_file_fclose(&fp_tmp);
1102 mx_mbox_close(m_fcc);
1103 goto done;
1104 }
1105
1106 const bool c_crypt_protected_headers_read = cs_subset_bool(sub, "crypt_protected_headers_read");
1107
1108 /* post == 1 => postpone message.
1109 * post == 0 => Normal mode. */
1110 mutt_rfc822_write_header(msg->fp, e->env, e->body,
1112 c_crypt_protected_headers_read &&
1114 sub);
1115
1116 /* (postponement) if this was a reply of some sort, <msgid> contains the
1117 * Message-ID: of message replied to. Save it using a special X-Mutt-
1118 * header so it can be picked up if the message is recalled at a later
1119 * point in time. This will allow the message to be marked as replied if
1120 * the same mailbox is still open. */
1121 if (post && msgid)
1122 fprintf(msg->fp, "Mutt-References: %s\n", msgid);
1123
1124 /* (postponement) save the Fcc: using a special X-Mutt- header so that
1125 * it can be picked up when the message is recalled */
1126 if (post && fcc)
1127 fprintf(msg->fp, "Mutt-Fcc: %s\n", fcc);
1128
1129 if ((m_fcc->type == MUTT_MMDF) || (m_fcc->type == MUTT_MBOX))
1130 fprintf(msg->fp, "Status: RO\n");
1131
1132 /* (postponement) if the mail is to be signed or encrypted, save this info */
1133 if (((WithCrypto & APPLICATION_PGP) != 0) && post && (e->security & APPLICATION_PGP))
1134 {
1135 fputs("Mutt-PGP: ", msg->fp);
1136 if (e->security & SEC_ENCRYPT)
1137 fputc('E', msg->fp);
1138 if (e->security & SEC_OPPENCRYPT)
1139 fputc('O', msg->fp);
1140 if (e->security & SEC_SIGN)
1141 {
1142 fputc('S', msg->fp);
1143
1144 const char *const c_pgp_sign_as = cs_subset_string(sub, "pgp_sign_as");
1145 if (c_pgp_sign_as)
1146 fprintf(msg->fp, "<%s>", c_pgp_sign_as);
1147 }
1148 if (e->security & SEC_INLINE)
1149 fputc('I', msg->fp);
1150#ifdef USE_AUTOCRYPT
1151 if (e->security & SEC_AUTOCRYPT)
1152 fputc('A', msg->fp);
1154 fputc('Z', msg->fp);
1155#endif
1156 fputc('\n', msg->fp);
1157 }
1158
1159 /* (postponement) if the mail is to be signed or encrypted, save this info */
1160 if (((WithCrypto & APPLICATION_SMIME) != 0) && post && (e->security & APPLICATION_SMIME))
1161 {
1162 fputs("Mutt-SMIME: ", msg->fp);
1163 if (e->security & SEC_ENCRYPT)
1164 {
1165 fputc('E', msg->fp);
1166
1167 const char *const c_smime_encrypt_with = cs_subset_string(sub, "smime_encrypt_with");
1168 if (c_smime_encrypt_with)
1169 fprintf(msg->fp, "C<%s>", c_smime_encrypt_with);
1170 }
1171 if (e->security & SEC_OPPENCRYPT)
1172 fputc('O', msg->fp);
1173 if (e->security & SEC_SIGN)
1174 {
1175 fputc('S', msg->fp);
1176
1177 const char *const c_smime_sign_as = cs_subset_string(sub, "smime_sign_as");
1178 if (c_smime_sign_as)
1179 fprintf(msg->fp, "<%s>", c_smime_sign_as);
1180 }
1181 if (e->security & SEC_INLINE)
1182 fputc('I', msg->fp);
1183 fputc('\n', msg->fp);
1184 }
1185
1186#ifdef MIXMASTER
1187 /* (postponement) if the mail is to be sent through a mixmaster
1188 * chain, save that information */
1189
1190 if (post && !STAILQ_EMPTY(&e->chain))
1191 {
1192 fputs("Mutt-Mix:", msg->fp);
1193 struct ListNode *p = NULL;
1194 STAILQ_FOREACH(p, &e->chain, entries)
1195 {
1196 fprintf(msg->fp, " %s", (char *) p->data);
1197 }
1198
1199 fputc('\n', msg->fp);
1200 }
1201#endif
1202
1203 if (fp_tmp)
1204 {
1205 mutt_write_mime_body(e->body, fp_tmp, sub);
1206
1207 /* make sure the last line ends with a newline. Emacs doesn't ensure this
1208 * will happen, and it can cause problems parsing the mailbox later. */
1209 if (mutt_file_seek(fp_tmp, -1, SEEK_END) && (fgetc(fp_tmp) != '\n') &&
1210 mutt_file_seek(fp_tmp, 0, SEEK_END))
1211 {
1212 fputc('\n', fp_tmp);
1213 }
1214
1215 fflush(fp_tmp);
1216 if (ferror(fp_tmp))
1217 {
1218 mutt_debug(LL_DEBUG1, "%s: write failed\n", buf_string(tempfile));
1219 mutt_file_fclose(&fp_tmp);
1220 unlink(buf_string(tempfile));
1221 mx_msg_commit(m_fcc, msg); /* XXX really? */
1222 mx_msg_close(m_fcc, &msg);
1223 mx_mbox_close(m_fcc);
1224 goto done;
1225 }
1226
1227 /* count the number of lines */
1228 int lines = 0;
1229 char line_buf[1024] = { 0 };
1230 rewind(fp_tmp);
1231 while (fgets(line_buf, sizeof(line_buf), fp_tmp))
1232 lines++;
1233 fprintf(msg->fp, "Content-Length: " OFF_T_FMT "\n", (LOFF_T) ftello(fp_tmp));
1234 fprintf(msg->fp, "Lines: %d\n\n", lines);
1235
1236 /* copy the body and clean up */
1237 rewind(fp_tmp);
1238 rc = mutt_file_copy_stream(fp_tmp, msg->fp);
1239 if (mutt_file_fclose(&fp_tmp) != 0)
1240 rc = -1;
1241 /* if there was an error, leave the temp version */
1242 if (rc >= 0)
1243 {
1244 unlink(buf_string(tempfile));
1245 rc = 0;
1246 }
1247 }
1248 else
1249 {
1250 fputc('\n', msg->fp); /* finish off the header */
1251 rc = mutt_write_mime_body(e->body, msg->fp, sub);
1252 }
1253
1254 if (mx_msg_commit(m_fcc, msg) != 0)
1255 rc = -1;
1256 else if (finalpath)
1257 *finalpath = mutt_str_dup(msg->committed_path);
1258 mx_msg_close(m_fcc, &msg);
1259 mx_mbox_close(m_fcc);
1260
1261 if (!post && need_mailbox_cleanup)
1262 mailbox_restore_timestamp(path, &st);
1263
1264 if (post)
1265 set_noconv_flags(e->body, false);
1266
1267done:
1268 m_fcc->append = old_append;
1269 mailbox_free(&m_fcc);
1270
1271#ifdef RECORD_FOLDER_HOOK
1272 /* We ran a folder hook for the destination mailbox,
1273 * now we run it for the user's current mailbox */
1274 const struct Mailbox *m_cur = get_current_mailbox();
1275 if (m_cur)
1276 mutt_folder_hook(m_cur->path, m_cur->desc);
1277#endif
1278
1279 if (fp_tmp)
1280 {
1281 mutt_file_fclose(&fp_tmp);
1282 unlink(buf_string(tempfile));
1283 }
1284 buf_pool_release(&tempfile);
1285
1286 return rc;
1287}
bool mutt_should_hide_protected_subject(struct Email *e)
Should NeoMutt hide the protected subject?
Definition: crypt.c:1089
int mutt_file_copy_stream(FILE *fp_in, FILE *fp_out)
Copy the contents of one file into another.
Definition: file.c:262
int mutt_rfc822_write_header(FILE *fp, struct Envelope *env, struct Body *b, enum MuttWriteHeaderMode mode, bool privacy, bool hide_protected_subject, struct ConfigSubset *sub)
Write out one RFC822 header line.
Definition: header.c:575
@ MUTT_WRITE_HEADER_FCC
fcc mode, like normal mode but for Bcc header
Definition: header.h:41
@ MUTT_WRITE_HEADER_POSTPONE
A postponed Email, just the envelope info.
Definition: header.h:42
void mutt_folder_hook(const char *path, const char *desc)
Perform a folder hook.
Definition: hook.c:597
struct Mailbox * get_current_mailbox(void)
Get the current Mailbox.
Definition: index.c:662
void mailbox_free(struct Mailbox **ptr)
Free a Mailbox.
Definition: mailbox.c:90
@ MUTT_MMDF
'mmdf' Mailbox type
Definition: mailbox.h:46
@ MUTT_MBOX
'mbox' Mailbox type
Definition: mailbox.h:45
void mailbox_restore_timestamp(const char *path, struct stat *st)
Restore the timestamp of a mailbox.
Definition: mutt_mailbox.c:412
bool mx_mbox_open(struct Mailbox *m, OpenMailboxFlags flags)
Open a mailbox and parse it.
Definition: mx.c:284
struct Message * mx_msg_open_new(struct Mailbox *m, const struct Email *e, MsgOpenFlags flags)
Open a new message.
Definition: mx.c:1034
int mx_msg_commit(struct Mailbox *m, struct Message *msg)
Commit a message to a folder - Wrapper for MxOps::msg_commit()
Definition: mx.c:1164
struct Mailbox * mx_path_resolve(const char *path)
Get a Mailbox for a path.
Definition: mx.c:1641
enum MxStatus mx_mbox_close(struct Mailbox *m)
Save changes and close mailbox.
Definition: mx.c:593
uint8_t MsgOpenFlags
Flags for mx_msg_open_new(), e.g. MUTT_ADD_FROM.
Definition: mx.h:38
#define MUTT_ADD_FROM
add a From_ line
Definition: mx.h:40
#define MUTT_SET_DRAFT
set the message draft flag
Definition: mx.h:41
#define MUTT_APPEND
Open mailbox for appending messages.
Definition: mxapi.h:42
#define MUTT_QUIET
Do not print any messages.
Definition: mxapi.h:44
#define SEC_INLINE
Email has an inline signature.
Definition: lib.h:86
#define SEC_AUTOCRYPT
(Autocrypt) Message will be, or was Autocrypt encrypt+signed
Definition: lib.h:88
#define SEC_OPPENCRYPT
Opportunistic encrypt mode.
Definition: lib.h:87
#define SEC_AUTOCRYPT_OVERRIDE
(Autocrypt) Indicates manual set/unset of encryption
Definition: lib.h:89
#define SEC_SIGN
Email is signed.
Definition: lib.h:80
#define STAILQ_EMPTY(head)
Definition: queue.h:348
static void set_noconv_flags(struct Body *b, bool flag)
Set/reset the "x-mutt-noconv" flag.
Definition: sendlib.c:973
bool read
Email is read.
Definition: email.h:48
struct ListHead chain
Mixmaster chain.
Definition: email.h:91
A mailbox.
Definition: mailbox.h:79
bool append
Mailbox is opened in append mode.
Definition: mailbox.h:108
enum MailboxType type
Mailbox type.
Definition: mailbox.h:102
struct ConfigSubset * sub
Inherited config items.
Definition: mailbox.h:83
char * committed_path
the final path generated by mx_msg_commit()
Definition: message.h:37
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_write_multiple_fcc()

int mutt_write_multiple_fcc ( const char *  path,
struct Email e,
const char *  msgid,
bool  post,
char *  fcc,
char **  finalpath,
struct ConfigSubset sub 
)

Handle FCC with multiple, comma separated entries.

Parameters
[in]pathPath to mailboxes (comma separated)
[in]eEmail
[in]msgidMessage id
[in]postIf true, postpone message
[in]fccfcc setting to save (postpone only)
[out]finalpathFinal path of email
[in]subConfig Subset
Return values
0Success
-1Failure

Definition at line 1003 of file sendlib.c.

1005{
1006 char fcc_tok[PATH_MAX] = { 0 };
1007 char fcc_expanded[PATH_MAX] = { 0 };
1008
1009 mutt_str_copy(fcc_tok, path, sizeof(fcc_tok));
1010
1011 char *tok = strtok(fcc_tok, ",");
1012 if (!tok)
1013 return -1;
1014
1015 mutt_debug(LL_DEBUG1, "Fcc: initial mailbox = '%s'\n", tok);
1016 /* mutt_expand_path already called above for the first token */
1017 int status = mutt_write_fcc(tok, e, msgid, post, fcc, finalpath, sub);
1018 if (status != 0)
1019 return status;
1020
1021 while ((tok = strtok(NULL, ",")))
1022 {
1023 if (*tok == '\0')
1024 continue;
1025
1026 /* Only call mutt_expand_path if tok has some data */
1027 mutt_debug(LL_DEBUG1, "Fcc: additional mailbox token = '%s'\n", tok);
1028 mutt_str_copy(fcc_expanded, tok, sizeof(fcc_expanded));
1029 mutt_expand_path(fcc_expanded, sizeof(fcc_expanded));
1030 mutt_debug(LL_DEBUG1, " Additional mailbox expanded = '%s'\n", fcc_expanded);
1031 status = mutt_write_fcc(fcc_expanded, e, msgid, post, fcc, finalpath, sub);
1032 if (status != 0)
1033 return status;
1034 }
1035
1036 return 0;
1037}
char * mutt_expand_path(char *buf, size_t buflen)
Create the canonical path.
Definition: muttlib.c:124
int mutt_write_fcc(const char *path, struct Email *e, const char *msgid, bool post, const char *fcc, char **finalpath, struct ConfigSubset *sub)
Write email to FCC mailbox.
Definition: sendlib.c:1051
+ Here is the call graph for this function:
+ Here is the caller graph for this function: