NeoMutt  2024-04-25-97-g7d2481
Teaching an old dog new tricks
DOXYGEN
Loading...
Searching...
No Matches
message.c File Reference

Maildir Message. More...

#include "config.h"
#include <dirent.h>
#include <errno.h>
#include <fcntl.h>
#include <inttypes.h>
#include <limits.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <utime.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "email/lib.h"
#include "core/lib.h"
#include "message.h"
#include "copy.h"
#include "edata.h"
#include "globals.h"
#include "hcache.h"
#include "mx.h"
#include "shared.h"
#include "sort.h"
+ Include dependency graph for message.c:

Go to the source code of this file.

Functions

int nm_update_filename (struct Mailbox *m, const char *old_file, const char *new_file, struct Email *e)
 Change the filename.
 
static int maildir_sort_flags (const void *a, const void *b, void *sdata)
 Compare two flag characters - Implements sort_t -.
 
void maildir_gen_flags (char *dest, size_t destlen, struct Email *e)
 Generate the Maildir flags for an email.
 
static FILE * maildir_open_find_message_dir (const char *folder, const char *unique, const char *subfolder, char **newname)
 Find a message in a maildir folder.
 
FILE * maildir_open_find_message (const char *folder, const char *msg, char **newname)
 Find a message by name.
 
static int maildir_sync_message (struct Mailbox *m, struct Email *e)
 Sync an email to a Maildir folder.
 
bool maildir_sync_mailbox_message (struct Mailbox *m, struct Email *e, struct HeaderCache *hc)
 Save changes to the mailbox.
 
static int maildir_commit_message (struct Mailbox *m, struct Message *msg, struct Email *e)
 Commit a message to a maildir folder.
 
int maildir_rewrite_message (struct Mailbox *m, struct Email *e)
 Sync a message in an Maildir folder.
 
bool maildir_msg_open (struct Mailbox *m, struct Message *msg, struct Email *e)
 Open an email message in a Mailbox - Implements MxOps::msg_open() -.
 
bool maildir_msg_open_new (struct Mailbox *m, struct Message *msg, const struct Email *e)
 Open a new message in a Mailbox - Implements MxOps::msg_open_new() -.
 
int maildir_msg_commit (struct Mailbox *m, struct Message *msg)
 Save changes to an email - Implements MxOps::msg_commit() -.
 
int maildir_msg_close (struct Mailbox *m, struct Message *msg)
 Close an email - Implements MxOps::msg_close() -.
 
int maildir_msg_save_hcache (struct Mailbox *m, struct Email *e)
 Save message to the header cache - Implements MxOps::msg_save_hcache() -.
 

Detailed Description

Maildir Message.

Authors
  • Richard Russon

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

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

Definition in file message.c.

Function Documentation

◆ nm_update_filename()

int nm_update_filename ( struct Mailbox m,
const char *  old_file,
const char *  new_file,
struct Email e 
)

Change the filename.

Parameters
mMailbox
old_fileOld filename
new_fileNew filename
eEmail
Return values
0Success
-1Failure

Definition at line 1763 of file notmuch.c.

1765{
1766 char buf[PATH_MAX] = { 0 };
1767 struct NmMboxData *mdata = nm_mdata_get(m);
1768 if (!mdata || !new_file)
1769 return -1;
1770
1771 if (!old_file && nm_edata_get(e))
1772 {
1773 email_get_fullpath(e, buf, sizeof(buf));
1774 old_file = buf;
1775 }
1776
1777 int rc = rename_filename(m, old_file, new_file, e);
1778
1779 nm_db_release(m);
1780 mdata->mtime.tv_sec = mutt_date_now();
1781 mdata->mtime.tv_nsec = 0;
1782 return rc;
1783}
time_t mutt_date_now(void)
Return the number of seconds since the Unix epoch.
Definition: date.c:456
#define PATH_MAX
Definition: mutt.h:42
int nm_db_release(struct Mailbox *m)
Close the Notmuch database.
Definition: db.c:233
struct NmEmailData * nm_edata_get(struct Email *e)
Get the Notmuch Email data.
Definition: edata.c:72
struct NmMboxData * nm_mdata_get(struct Mailbox *m)
Get the Notmuch Mailbox data.
Definition: mdata.c:96
static char * email_get_fullpath(struct Email *e, char *buf, size_t buflen)
Get the full path of an email.
Definition: notmuch.c:237
static int rename_filename(struct Mailbox *m, const char *old_file, const char *new_file, struct Email *e)
Rename the file.
Definition: notmuch.c:1331
void * mdata
Driver specific data.
Definition: mailbox.h:132
Notmuch-specific Mailbox data -.
Definition: mdata.h:35
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ maildir_gen_flags()

void maildir_gen_flags ( char *  dest,
size_t  destlen,
struct Email e 
)

Generate the Maildir flags for an email.

Parameters
destBuffer for the result
destlenLength of buffer
eEmail

Definition at line 73 of file message.c.

74{
75 *dest = '\0';
76
77 const char *flags = NULL;
78
80 if (edata)
81 flags = edata->custom_flags;
82
83 /* The maildir specification requires that all files in the cur
84 * subdirectory have the :unique string appended, regardless of whether
85 * or not there are any flags. If .old is set, we know that this message
86 * will end up in the cur directory, so we include it in the following
87 * test even though there is no associated flag. */
88
89 if (e->flagged || e->replied || e->read || e->deleted || e->old || flags)
90 {
91 char tmp[1024] = { 0 };
92 snprintf(tmp, sizeof(tmp), "%s%s%s%s%s", e->flagged ? "F" : "", e->replied ? "R" : "",
93 e->read ? "S" : "", e->deleted ? "T" : "", NONULL(flags));
94 if (flags)
95 mutt_qsort_r(tmp, strlen(tmp), 1, maildir_sort_flags, NULL);
96
97 const char c_maildir_field_delimiter = *cc_maildir_field_delimiter();
98 snprintf(dest, destlen, "%c2,%s", c_maildir_field_delimiter, tmp);
99 }
100}
const char * cc_maildir_field_delimiter(void)
Get the cached value of $maildir_field_delimiter.
Definition: config_cache.c:131
static int maildir_sort_flags(const void *a, const void *b, void *sdata)
Compare two flag characters - Implements sort_t -.
Definition: message.c:62
struct MaildirEmailData * maildir_edata_get(struct Email *e)
Get the private data for this Email.
Definition: edata.c:64
void mutt_qsort_r(void *base, size_t nmemb, size_t size, sort_t compar, void *sdata)
Sort an array, where the comparator has access to opaque data rather than requiring global variables.
Definition: qsort_r.c:67
#define NONULL(x)
Definition: string2.h:37
bool read
Email is read.
Definition: email.h:50
void * edata
Driver-specific data.
Definition: email.h:74
bool old
Email is seen, but unread.
Definition: email.h:49
bool flagged
Marked important?
Definition: email.h:47
bool replied
Email has been replied to.
Definition: email.h:51
bool deleted
Email is deleted.
Definition: email.h:78
Maildir-specific Email data -.
Definition: edata.h:32
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ maildir_open_find_message_dir()

static FILE * maildir_open_find_message_dir ( const char *  folder,
const char *  unique,
const char *  subfolder,
char **  newname 
)
static

Find a message in a maildir folder.

Parameters
[in]folderBase folder
[in]uniqueUnique part of filename
[in]subfolderSubfolder to search, e.g. 'cur'
[out]newnameFile's new name
Return values
ptrFile handle

These functions try to find a message in a maildir folder when it has moved under our feet. Note that this code is rather expensive, but then again, it's called rarely.

Definition at line 114 of file message.c.

116{
117 struct Buffer *dirname = buf_pool_get();
118 struct Buffer *tunique = buf_pool_get();
119 struct Buffer *fname = buf_pool_get();
120
121 struct dirent *de = NULL;
122
123 FILE *fp = NULL;
124 int oe = ENOENT;
125
126 buf_printf(dirname, "%s/%s", folder, subfolder);
127
129 if (!dir)
130 {
131 errno = ENOENT;
132 goto cleanup;
133 }
134
135 while ((de = readdir(dir)))
136 {
137 maildir_canon_filename(tunique, de->d_name);
138
139 if (mutt_str_equal(buf_string(tunique), unique))
140 {
141 buf_printf(fname, "%s/%s/%s", folder, subfolder, de->d_name);
142 fp = mutt_file_fopen(buf_string(fname), "r");
143 oe = errno;
144 break;
145 }
146 }
147
148 closedir(dir);
149
150 if (newname && fp)
151 *newname = buf_strdup(fname);
152
153 errno = oe;
154
155cleanup:
156 buf_pool_release(&dirname);
157 buf_pool_release(&tunique);
158 buf_pool_release(&fname);
159
160 return fp;
161}
int buf_printf(struct Buffer *buf, const char *fmt,...)
Format a string overwriting a Buffer.
Definition: buffer.c:161
char * buf_strdup(const struct Buffer *buf)
Copy a Buffer's string.
Definition: buffer.c:571
static const char * buf_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:96
DIR * mutt_file_opendir(const char *path, enum MuttOpenDirMode mode)
Open a directory.
Definition: file.c:642
@ MUTT_OPENDIR_CREATE
Create the directory if it doesn't exist.
Definition: file.h:75
#define mutt_file_fopen(PATH, MODE)
Definition: file.h:148
void maildir_canon_filename(struct Buffer *dest, const char *src)
Generate the canonical filename for a Maildir folder.
Definition: shared.c:73
bool mutt_str_equal(const char *a, const char *b)
Compare two strings.
Definition: string.c:660
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:

◆ maildir_open_find_message()

FILE * maildir_open_find_message ( const char *  folder,
const char *  msg,
char **  newname 
)

Find a message by name.

Parameters
[in]folderMaildir path
[in]msgEmail path
[out]newnameNew name, if it has moved
Return values
ptrFile handle

Definition at line 170 of file message.c.

171{
172 static unsigned int new_hits = 0, cur_hits = 0; /* simple dynamic optimization */
173
174 struct Buffer *unique = buf_pool_get();
175 maildir_canon_filename(unique, msg);
176
177 FILE *fp = maildir_open_find_message_dir(folder, buf_string(unique),
178 (new_hits > cur_hits) ? "new" : "cur", newname);
179 if (fp || (errno != ENOENT))
180 {
181 if ((new_hits < UINT_MAX) && (cur_hits < UINT_MAX))
182 {
183 new_hits += ((new_hits > cur_hits) ? 1 : 0);
184 cur_hits += ((new_hits > cur_hits) ? 0 : 1);
185 }
186
187 goto cleanup;
188 }
189 fp = maildir_open_find_message_dir(folder, buf_string(unique),
190 (new_hits > cur_hits) ? "cur" : "new", newname);
191 if (fp || (errno != ENOENT))
192 {
193 if ((new_hits < UINT_MAX) && (cur_hits < UINT_MAX))
194 {
195 new_hits += ((new_hits > cur_hits) ? 0 : 1);
196 cur_hits += ((new_hits > cur_hits) ? 1 : 0);
197 }
198
199 goto cleanup;
200 }
201
202 fp = NULL;
203
204cleanup:
205 buf_pool_release(&unique);
206
207 return fp;
208}
static FILE * maildir_open_find_message_dir(const char *folder, const char *unique, const char *subfolder, char **newname)
Find a message in a maildir folder.
Definition: message.c:114
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ maildir_sync_message()

static int maildir_sync_message ( struct Mailbox m,
struct Email e 
)
static

Sync an email to a Maildir folder.

Parameters
mMailbox
eEmail
Return values
0Success
-1Error

Definition at line 217 of file message.c.

218{
219 if (!m || !e)
220 return -1;
221
222 struct Buffer *newpath = NULL;
223 struct Buffer *partpath = NULL;
224 struct Buffer *fullpath = NULL;
225 struct Buffer *oldpath = NULL;
226 char suffix[16] = { 0 };
227 int rc = 0;
228
229 if (e->attach_del || e->env->changed)
230 {
231 /* when doing attachment deletion/rethreading, fall back to the maildir case. */
232 if (maildir_rewrite_message(m, e) != 0)
233 return -1;
234 e->env->changed = false;
235 }
236 else
237 {
238 /* we just have to rename the file. */
239
240 char *p = strrchr(e->path, '/');
241 if (!p)
242 {
243 mutt_debug(LL_DEBUG1, "%s: unable to find subdir!\n", e->path);
244 return -1;
245 }
246 p++;
247 newpath = buf_pool_get();
248 partpath = buf_pool_get();
249 fullpath = buf_pool_get();
250 oldpath = buf_pool_get();
251
252 buf_strcpy(newpath, p);
253
254 /* kill the previous flags */
255 const char c_maildir_field_delimiter = *cc_maildir_field_delimiter();
256 p = strchr(newpath->data, c_maildir_field_delimiter);
257 if (p)
258 {
259 *p = '\0';
260 newpath->dptr = p; /* fix buffer up, just to be safe */
261 }
262
263 maildir_gen_flags(suffix, sizeof(suffix), e);
264
265 buf_printf(partpath, "%s/%s%s", (e->read || e->old) ? "cur" : "new",
266 buf_string(newpath), suffix);
267 buf_printf(fullpath, "%s/%s", mailbox_path(m), buf_string(partpath));
268 buf_printf(oldpath, "%s/%s", mailbox_path(m), e->path);
269
270 if (mutt_str_equal(buf_string(fullpath), buf_string(oldpath)))
271 {
272 /* message hasn't really changed */
273 goto cleanup;
274 }
275
276 /* record that the message is possibly marked as trashed on disk */
277 e->trash = e->deleted;
278
279 struct stat st = { 0 };
280 if (stat(buf_string(oldpath), &st) == -1)
281 {
282 mutt_debug(LL_DEBUG1, "File already removed (just continuing)");
283 goto cleanup;
284 }
285
286 if (rename(buf_string(oldpath), buf_string(fullpath)) != 0)
287 {
288 mutt_perror("rename");
289 rc = -1;
290 goto cleanup;
291 }
292 mutt_str_replace(&e->path, buf_string(partpath));
293 }
294
295cleanup:
296 buf_pool_release(&newpath);
297 buf_pool_release(&partpath);
298 buf_pool_release(&fullpath);
299 buf_pool_release(&oldpath);
300
301 return rc;
302}
size_t buf_strcpy(struct Buffer *buf, const char *s)
Copy a string into a Buffer.
Definition: buffer.c:395
static const char * mailbox_path(const struct Mailbox *m)
Get the Mailbox's path string.
Definition: mailbox.h:223
#define mutt_debug(LEVEL,...)
Definition: logging2.h:89
#define mutt_perror(...)
Definition: logging2.h:93
@ LL_DEBUG1
Log at debug level 1.
Definition: logging2.h:43
int maildir_rewrite_message(struct Mailbox *m, struct Email *e)
Sync a message in an Maildir folder.
Definition: message.c:454
void maildir_gen_flags(char *dest, size_t destlen, struct Email *e)
Generate the Maildir flags for an email.
Definition: message.c:73
char * mutt_str_replace(char **p, const char *s)
Replace one string with another.
Definition: string.c:280
char * dptr
Current read/write position.
Definition: buffer.h:38
char * data
Pointer to data.
Definition: buffer.h:37
struct Envelope * env
Envelope information.
Definition: email.h:68
bool attach_del
Has an attachment marked for deletion.
Definition: email.h:99
char * path
Path of Email (for local Mailboxes)
Definition: email.h:70
bool trash
Message is marked as trashed on disk (used by the maildir_trash option)
Definition: email.h:53
unsigned char changed
Changed fields, e.g. MUTT_ENV_CHANGED_SUBJECT.
Definition: envelope.h:90
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ maildir_sync_mailbox_message()

bool maildir_sync_mailbox_message ( struct Mailbox m,
struct Email e,
struct HeaderCache hc 
)

Save changes to the mailbox.

Parameters
mMailbox
eEmail
hcHeader cache handle
Return values
trueSuccess
falseError

Definition at line 312 of file message.c.

313{
314 if (!e)
315 return false;
316
317 const bool c_maildir_trash = cs_subset_bool(NeoMutt->sub, "maildir_trash");
318 if (e->deleted && !c_maildir_trash)
319 {
320 char path[PATH_MAX] = { 0 };
321 snprintf(path, sizeof(path), "%s/%s", mailbox_path(m), e->path);
323 unlink(path);
324 }
325 else if (e->changed || e->attach_del ||
326 ((c_maildir_trash || e->trash) && (e->deleted != e->trash)))
327 {
328 if (maildir_sync_message(m, e) == -1)
329 return false;
330 }
331
332 if (e->changed)
334
335 return true;
336}
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:47
int maildir_hcache_store(struct HeaderCache *hc, struct Email *e)
Save an Email to the Header Cache.
Definition: hcache.c:155
int maildir_hcache_delete(struct HeaderCache *hc, struct Email *e)
Delete an Email from the Header Cache.
Definition: hcache.c:81
static int maildir_sync_message(struct Mailbox *m, struct Email *e)
Sync an email to a Maildir folder.
Definition: message.c:217
bool changed
Email has been edited.
Definition: email.h:77
Container for Accounts, Notifications.
Definition: neomutt.h:42
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:46
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ maildir_commit_message()

static int maildir_commit_message ( struct Mailbox m,
struct Message msg,
struct Email e 
)
static

Commit a message to a maildir folder.

Parameters
mMailbox
msgMessage to commit
eEmail
Return values
0Success
-1Failure

msg->path contains the file name of a file in tmp/. We take the flags from this file's name.

m is the mail folder we commit to.

e is a header structure to which we write the message's new file name. This is used in the maildir folder sync routines. When this routine is invoked from mx_msg_commit(), e is NULL.

msg->path looks like this:

tmp/{cur,new}.neomutt-HOSTNAME-PID-COUNTER:flags

See also maildir_msg_open_new().

Definition at line 361 of file message.c.

362{
363 char subdir[4] = { 0 };
364 char suffix[16] = { 0 };
365 int rc = 0;
366
367 if (mutt_file_fsync_close(&msg->fp))
368 {
369 mutt_perror(_("Could not flush message to disk"));
370 return -1;
371 }
372
373 /* extract the subdir */
374 char *s = strrchr(msg->path, '/') + 1;
375 mutt_str_copy(subdir, s, 4);
376
377 /* extract the flags */
378 const char c_maildir_field_delimiter = *cc_maildir_field_delimiter();
379 s = strchr(s, c_maildir_field_delimiter);
380 if (s)
381 mutt_str_copy(suffix, s, sizeof(suffix));
382 else
383 suffix[0] = '\0';
384
385 /* construct a new file name. */
386 struct Buffer *path = buf_pool_get();
387 struct Buffer *full = buf_pool_get();
388 while (true)
389 {
390 buf_printf(path, "%s/%lld.R%" PRIu64 ".%s%s", subdir, (long long) mutt_date_now(),
391 mutt_rand64(), NONULL(ShortHostname), suffix);
392 buf_printf(full, "%s/%s", mailbox_path(m), buf_string(path));
393
394 mutt_debug(LL_DEBUG2, "renaming %s to %s\n", msg->path, buf_string(full));
395
396 if (mutt_file_safe_rename(msg->path, buf_string(full)) == 0)
397 {
398 /* Adjust the mtime on the file to match the time at which this
399 * message was received. Currently this is only set when copying
400 * messages between mailboxes, so we test to ensure that it is
401 * actually set. */
402 if (msg->received != 0)
403 {
404 struct utimbuf ut = { 0 };
405 int rc_utime;
406
407 ut.actime = msg->received;
408 ut.modtime = msg->received;
409 do
410 {
411 rc_utime = utime(buf_string(full), &ut);
412 } while ((rc_utime == -1) && (errno == EINTR));
413 if (rc_utime == -1)
414 {
415 mutt_perror(_("maildir_commit_message(): unable to set time on file"));
416 rc = -1;
417 goto cleanup;
418 }
419 }
420
421#ifdef USE_NOTMUCH
422 if (m->type == MUTT_NOTMUCH)
423 nm_update_filename(m, e->path, buf_string(full), e);
424#endif
425 if (e)
426 mutt_str_replace(&e->path, buf_string(path));
428 FREE(&msg->path);
429
430 goto cleanup;
431 }
432 else if (errno != EEXIST)
433 {
434 mutt_perror("%s", mailbox_path(m));
435 rc = -1;
436 goto cleanup;
437 }
438 }
439
440cleanup:
441 buf_pool_release(&path);
442 buf_pool_release(&full);
443
444 return rc;
445}
@ MUTT_NOTMUCH
'Notmuch' (virtual) Mailbox type
Definition: mailbox.h:51
int mutt_file_safe_rename(const char *src, const char *target)
NFS-safe renaming of files.
Definition: file.c:371
int mutt_file_fsync_close(FILE **fp)
Flush the data, before closing a file (and NULL the pointer)
Definition: file.c:193
char * ShortHostname
Short version of the hostname.
Definition: globals.c:39
@ LL_DEBUG2
Log at debug level 2.
Definition: logging2.h:44
int nm_update_filename(struct Mailbox *m, const char *old_file, const char *new_file, struct Email *e)
Change the filename.
Definition: notmuch.c:1763
#define FREE(x)
Definition: memory.h:45
#define _(a)
Definition: message.h:28
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:581
uint64_t mutt_rand64(void)
Create a 64-bit random number.
Definition: random.c:123
enum MailboxType type
Mailbox type.
Definition: mailbox.h:102
FILE * fp
pointer to the message data
Definition: message.h:35
char * path
path to temp file
Definition: message.h:36
char * committed_path
the final path generated by mx_msg_commit()
Definition: message.h:37
time_t received
Time at which this message was received.
Definition: message.h:46
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ maildir_rewrite_message()

int maildir_rewrite_message ( struct Mailbox m,
struct Email e 
)

Sync a message in an Maildir folder.

Parameters
mMailbox
eEmail
Return values
0Success
-1Error

Definition at line 454 of file message.c.

455{
456 if (!m || !e)
457 return -1;
458
459 bool restore = true;
460
461 long old_body_offset = e->body->offset;
462 long old_body_length = e->body->length;
463 long old_hdr_lines = e->lines;
464
465 struct Message *src = mx_msg_open(m, e);
466 struct Message *dest = mx_msg_open_new(m, e, MUTT_MSG_NO_FLAGS);
467 if (!src || !dest)
468 return -1;
469
470 int rc = mutt_copy_message(dest->fp, e, src, MUTT_CM_UPDATE, CH_UPDATE | CH_UPDATE_LEN, 0);
471 if (rc == 0)
472 {
473 char oldpath[PATH_MAX] = { 0 };
474 char partpath[PATH_MAX] = { 0 };
475 snprintf(oldpath, sizeof(oldpath), "%s/%s", mailbox_path(m), e->path);
476 mutt_str_copy(partpath, e->path, sizeof(partpath));
477
478 rc = maildir_commit_message(m, dest, e);
479
480 if (rc == 0)
481 {
482 unlink(oldpath);
483 restore = false;
484 }
485 }
486 mx_msg_close(m, &src);
487 mx_msg_close(m, &dest);
488
489 if ((rc == -1) && restore)
490 {
491 e->body->offset = old_body_offset;
492 e->body->length = old_body_length;
493 e->lines = old_hdr_lines;
494 }
495
497 return rc;
498}
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:907
#define MUTT_CM_UPDATE
Update structs on sync.
Definition: copy.h:42
#define CH_UPDATE
Update the status and x-status fields?
Definition: copy.h:54
#define CH_UPDATE_LEN
Update Lines: and Content-Length:
Definition: copy.h:64
void mutt_body_free(struct Body **ptr)
Free a Body.
Definition: body.c:58
static int maildir_commit_message(struct Mailbox *m, struct Message *msg, struct Email *e)
Commit a message to a maildir folder.
Definition: message.c:361
int mx_msg_close(struct Mailbox *m, struct Message **ptr)
Close a message.
Definition: mx.c:1180
struct Message * mx_msg_open(struct Mailbox *m, struct Email *e)
Return a stream pointer for a message.
Definition: mx.c:1134
struct Message * mx_msg_open_new(struct Mailbox *m, const struct Email *e, MsgOpenFlags flags)
Open a new message.
Definition: mx.c:1040
#define MUTT_MSG_NO_FLAGS
No flags are set.
Definition: mx.h:38
struct Body * parts
parts of a multipart or message/rfc822
Definition: body.h:73
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
int lines
How many lines in the body of this message?
Definition: email.h:62
struct Body * body
List of MIME parts.
Definition: email.h:69
A local copy of an email.
Definition: message.h:34
+ Here is the call graph for this function:
+ Here is the caller graph for this function: