NeoMutt  2024-03-23-142-g2b2e76
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 <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:455
#define PATH_MAX
Definition: mutt.h:42
int nm_db_release(struct Mailbox *m)
Close the Notmuch database.
Definition: db.c:232
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 72 of file message.c.

73{
74 *dest = '\0';
75
76 const char *flags = NULL;
77
79 if (edata)
80 flags = edata->custom_flags;
81
82 /* The maildir specification requires that all files in the cur
83 * subdirectory have the :unique string appended, regardless of whether
84 * or not there are any flags. If .old is set, we know that this message
85 * will end up in the cur directory, so we include it in the following
86 * test even though there is no associated flag. */
87
88 if (e->flagged || e->replied || e->read || e->deleted || e->old || flags)
89 {
90 char tmp[1024] = { 0 };
91 snprintf(tmp, sizeof(tmp), "%s%s%s%s%s", e->flagged ? "F" : "", e->replied ? "R" : "",
92 e->read ? "S" : "", e->deleted ? "T" : "", NONULL(flags));
93 if (flags)
94 mutt_qsort_r(tmp, strlen(tmp), 1, maildir_sort_flags, NULL);
95
96 const char c_maildir_field_delimiter = *cc_maildir_field_delimiter();
97 snprintf(dest, destlen, "%c2,%s", c_maildir_field_delimiter, tmp);
98 }
99}
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:61
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 113 of file message.c.

115{
116 struct Buffer *dirname = buf_pool_get();
117 struct Buffer *tunique = buf_pool_get();
118 struct Buffer *fname = buf_pool_get();
119
120 struct dirent *de = NULL;
121
122 FILE *fp = NULL;
123 int oe = ENOENT;
124
125 buf_printf(dirname, "%s/%s", folder, subfolder);
126
128 if (!dir)
129 {
130 errno = ENOENT;
131 goto cleanup;
132 }
133
134 while ((de = readdir(dir)))
135 {
136 maildir_canon_filename(tunique, de->d_name);
137
138 if (mutt_str_equal(buf_string(tunique), unique))
139 {
140 buf_printf(fname, "%s/%s/%s", folder, subfolder, de->d_name);
141 fp = mutt_file_fopen(buf_string(fname), "r");
142 oe = errno;
143 break;
144 }
145 }
146
147 closedir(dir);
148
149 if (newname && fp)
150 *newname = buf_strdup(fname);
151
152 errno = oe;
153
154cleanup:
155 buf_pool_release(&dirname);
156 buf_pool_release(&tunique);
157 buf_pool_release(&fname);
158
159 return fp;
160}
int buf_printf(struct Buffer *buf, const char *fmt,...)
Format a string overwriting a Buffer.
Definition: buffer.c:160
char * buf_strdup(const struct Buffer *buf)
Copy a Buffer's string.
Definition: buffer.c:570
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:640
@ MUTT_OPENDIR_CREATE
Create the directory if it doesn't exist.
Definition: file.h:75
#define mutt_file_fopen(PATH, MODE)
Definition: file.h:146
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:709
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 169 of file message.c.

170{
171 static unsigned int new_hits = 0, cur_hits = 0; /* simple dynamic optimization */
172
173 struct Buffer *unique = buf_pool_get();
174 maildir_canon_filename(unique, msg);
175
176 FILE *fp = maildir_open_find_message_dir(folder, buf_string(unique),
177 (new_hits > cur_hits) ? "new" : "cur", newname);
178 if (fp || (errno != ENOENT))
179 {
180 if ((new_hits < UINT_MAX) && (cur_hits < UINT_MAX))
181 {
182 new_hits += ((new_hits > cur_hits) ? 1 : 0);
183 cur_hits += ((new_hits > cur_hits) ? 0 : 1);
184 }
185
186 goto cleanup;
187 }
188 fp = maildir_open_find_message_dir(folder, buf_string(unique),
189 (new_hits > cur_hits) ? "cur" : "new", newname);
190 if (fp || (errno != ENOENT))
191 {
192 if ((new_hits < UINT_MAX) && (cur_hits < UINT_MAX))
193 {
194 new_hits += ((new_hits > cur_hits) ? 0 : 1);
195 cur_hits += ((new_hits > cur_hits) ? 1 : 0);
196 }
197
198 goto cleanup;
199 }
200
201 fp = NULL;
202
203cleanup:
204 buf_pool_release(&unique);
205
206 return fp;
207}
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:113
+ 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 216 of file message.c.

217{
218 if (!m || !e)
219 return -1;
220
221 struct Buffer *newpath = NULL;
222 struct Buffer *partpath = NULL;
223 struct Buffer *fullpath = NULL;
224 struct Buffer *oldpath = NULL;
225 char suffix[16] = { 0 };
226 int rc = 0;
227
228 if (e->attach_del || e->env->changed)
229 {
230 /* when doing attachment deletion/rethreading, fall back to the maildir case. */
231 if (maildir_rewrite_message(m, e) != 0)
232 return -1;
233 e->env->changed = false;
234 }
235 else
236 {
237 /* we just have to rename the file. */
238
239 char *p = strrchr(e->path, '/');
240 if (!p)
241 {
242 mutt_debug(LL_DEBUG1, "%s: unable to find subdir!\n", e->path);
243 return -1;
244 }
245 p++;
246 newpath = buf_pool_get();
247 partpath = buf_pool_get();
248 fullpath = buf_pool_get();
249 oldpath = buf_pool_get();
250
251 buf_strcpy(newpath, p);
252
253 /* kill the previous flags */
254 const char c_maildir_field_delimiter = *cc_maildir_field_delimiter();
255 p = strchr(newpath->data, c_maildir_field_delimiter);
256 if (p)
257 {
258 *p = '\0';
259 newpath->dptr = p; /* fix buffer up, just to be safe */
260 }
261
262 maildir_gen_flags(suffix, sizeof(suffix), e);
263
264 buf_printf(partpath, "%s/%s%s", (e->read || e->old) ? "cur" : "new",
265 buf_string(newpath), suffix);
266 buf_printf(fullpath, "%s/%s", mailbox_path(m), buf_string(partpath));
267 buf_printf(oldpath, "%s/%s", mailbox_path(m), e->path);
268
269 if (mutt_str_equal(buf_string(fullpath), buf_string(oldpath)))
270 {
271 /* message hasn't really changed */
272 goto cleanup;
273 }
274
275 /* record that the message is possibly marked as trashed on disk */
276 e->trash = e->deleted;
277
278 struct stat st = { 0 };
279 if (stat(buf_string(oldpath), &st) == -1)
280 {
281 mutt_debug(LL_DEBUG1, "File already removed (just continuing)");
282 goto cleanup;
283 }
284
285 if (rename(buf_string(oldpath), buf_string(fullpath)) != 0)
286 {
287 mutt_perror("rename");
288 rc = -1;
289 goto cleanup;
290 }
291 mutt_str_replace(&e->path, buf_string(partpath));
292 }
293
294cleanup:
295 buf_pool_release(&newpath);
296 buf_pool_release(&partpath);
297 buf_pool_release(&fullpath);
298 buf_pool_release(&oldpath);
299
300 return rc;
301}
size_t buf_strcpy(struct Buffer *buf, const char *s)
Copy a string into a Buffer.
Definition: buffer.c:394
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:453
void maildir_gen_flags(char *dest, size_t destlen, struct Email *e)
Generate the Maildir flags for an email.
Definition: message.c:72
char * mutt_str_replace(char **p, const char *s)
Replace one string with another.
Definition: string.c:329
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:102
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 311 of file message.c.

312{
313 if (!e)
314 return false;
315
316 const bool c_maildir_trash = cs_subset_bool(NeoMutt->sub, "maildir_trash");
317 if (e->deleted && !c_maildir_trash)
318 {
319 char path[PATH_MAX] = { 0 };
320 snprintf(path, sizeof(path), "%s/%s", mailbox_path(m), e->path);
322 unlink(path);
323 }
324 else if (e->changed || e->attach_del ||
325 ((c_maildir_trash || e->trash) && (e->deleted != e->trash)))
326 {
327 if (maildir_sync_message(m, e) == -1)
328 return false;
329 }
330
331 if (e->changed)
333
334 return true;
335}
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:48
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:216
bool changed
Email has been edited.
Definition: email.h:77
Container for Accounts, Notifications.
Definition: neomutt.h:41
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:45
+ 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 360 of file message.c.

361{
362 char subdir[4] = { 0 };
363 char suffix[16] = { 0 };
364 int rc = 0;
365
366 if (mutt_file_fsync_close(&msg->fp))
367 {
368 mutt_perror(_("Could not flush message to disk"));
369 return -1;
370 }
371
372 /* extract the subdir */
373 char *s = strrchr(msg->path, '/') + 1;
374 mutt_str_copy(subdir, s, 4);
375
376 /* extract the flags */
377 const char c_maildir_field_delimiter = *cc_maildir_field_delimiter();
378 s = strchr(s, c_maildir_field_delimiter);
379 if (s)
380 mutt_str_copy(suffix, s, sizeof(suffix));
381 else
382 suffix[0] = '\0';
383
384 /* construct a new file name. */
385 struct Buffer *path = buf_pool_get();
386 struct Buffer *full = buf_pool_get();
387 while (true)
388 {
389 buf_printf(path, "%s/%lld.R%" PRIu64 ".%s%s", subdir, (long long) mutt_date_now(),
390 mutt_rand64(), NONULL(ShortHostname), suffix);
391 buf_printf(full, "%s/%s", mailbox_path(m), buf_string(path));
392
393 mutt_debug(LL_DEBUG2, "renaming %s to %s\n", msg->path, buf_string(full));
394
395 if (mutt_file_safe_rename(msg->path, buf_string(full)) == 0)
396 {
397 /* Adjust the mtime on the file to match the time at which this
398 * message was received. Currently this is only set when copying
399 * messages between mailboxes, so we test to ensure that it is
400 * actually set. */
401 if (msg->received != 0)
402 {
403 struct utimbuf ut = { 0 };
404 int rc_utime;
405
406 ut.actime = msg->received;
407 ut.modtime = msg->received;
408 do
409 {
410 rc_utime = utime(buf_string(full), &ut);
411 } while ((rc_utime == -1) && (errno == EINTR));
412 if (rc_utime == -1)
413 {
414 mutt_perror(_("maildir_commit_message(): unable to set time on file"));
415 rc = -1;
416 goto cleanup;
417 }
418 }
419
420#ifdef USE_NOTMUCH
421 if (m->type == MUTT_NOTMUCH)
422 nm_update_filename(m, e->path, buf_string(full), e);
423#endif
424 if (e)
425 mutt_str_replace(&e->path, buf_string(path));
427 FREE(&msg->path);
428
429 goto cleanup;
430 }
431 else if (errno != EEXIST)
432 {
433 mutt_perror("%s", mailbox_path(m));
434 rc = -1;
435 goto cleanup;
436 }
437 }
438
439cleanup:
440 buf_pool_release(&path);
441 buf_pool_release(&full);
442
443 return rc;
444}
@ 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:370
int mutt_file_fsync_close(FILE **fp)
Flush the data, before closing a file (and NULL the pointer)
Definition: file.c:192
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:630
uint64_t mutt_rand64(void)
Create a 64-bit random number.
Definition: random.c:122
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 453 of file message.c.

454{
455 if (!m || !e)
456 return -1;
457
458 bool restore = true;
459
460 long old_body_offset = e->body->offset;
461 long old_body_length = e->body->length;
462 long old_hdr_lines = e->lines;
463
464 struct Message *src = mx_msg_open(m, e);
465 struct Message *dest = mx_msg_open_new(m, e, MUTT_MSG_NO_FLAGS);
466 if (!src || !dest)
467 return -1;
468
469 int rc = mutt_copy_message(dest->fp, e, src, MUTT_CM_UPDATE, CH_UPDATE | CH_UPDATE_LEN, 0);
470 if (rc == 0)
471 {
472 char oldpath[PATH_MAX] = { 0 };
473 char partpath[PATH_MAX] = { 0 };
474 snprintf(oldpath, sizeof(oldpath), "%s/%s", mailbox_path(m), e->path);
475 mutt_str_copy(partpath, e->path, sizeof(partpath));
476
477 rc = maildir_commit_message(m, dest, e);
478
479 if (rc == 0)
480 {
481 unlink(oldpath);
482 restore = false;
483 }
484 }
485 mx_msg_close(m, &src);
486 mx_msg_close(m, &dest);
487
488 if ((rc == -1) && restore)
489 {
490 e->body->offset = old_body_offset;
491 e->body->length = old_body_length;
492 e->lines = old_hdr_lines;
493 }
494
496 return rc;
497}
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:360
int mx_msg_close(struct Mailbox *m, struct Message **ptr)
Close a message.
Definition: mx.c:1178
struct Message * mx_msg_open(struct Mailbox *m, struct Email *e)
Return a stream pointer for a message.
Definition: mx.c:1132
struct Message * mx_msg_open_new(struct Mailbox *m, const struct Email *e, MsgOpenFlags flags)
Open a new message.
Definition: mx.c:1038
#define MUTT_MSG_NO_FLAGS
No flags are set.
Definition: mx.h:39
struct Body * parts
parts of a multipart or message/rfc822
Definition: body.h:72
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: