NeoMutt  2024-03-23-147-g885fbc
Teaching an old dog new tricks
DOXYGEN
Loading...
Searching...
No Matches
mbox.c File Reference

Mbox local mailbox type. More...

#include "config.h"
#include <errno.h>
#include <fcntl.h>
#include <inttypes.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>
#include <utime.h>
#include "mutt/lib.h"
#include "address/lib.h"
#include "config/lib.h"
#include "email/lib.h"
#include "core/lib.h"
#include "mutt.h"
#include "lib.h"
#include "progress/lib.h"
#include "copy.h"
#include "globals.h"
#include "mutt_header.h"
#include "muttlib.h"
#include "mx.h"
#include "protos.h"
#include "sort.h"
+ Include dependency graph for mbox.c:

Go to the source code of this file.

Data Structures

struct  MUpdate
 Store of new offsets, used by mutt_sync_mailbox() More...
 

Functions

static void mbox_adata_free (void **ptr)
 Free the private Account data - Implements Account::adata_free() -.
 
static struct MboxAccountDatambox_adata_new (void)
 Create a new MboxAccountData struct.
 
static int init_mailbox (struct Mailbox *m)
 Add Mbox data to the Mailbox.
 
static struct MboxAccountDatambox_adata_get (struct Mailbox *m)
 Get the private data associated with a Mailbox.
 
static int mbox_lock_mailbox (struct Mailbox *m, bool excl, bool retry)
 Lock a mailbox.
 
static void mbox_unlock_mailbox (struct Mailbox *m)
 Unlock a mailbox.
 
static enum MxOpenReturns mmdf_parse_mailbox (struct Mailbox *m)
 Read a mailbox in MMDF format.
 
static enum MxOpenReturns mbox_parse_mailbox (struct Mailbox *m)
 Read a mailbox from disk.
 
static int reopen_mailbox (struct Mailbox *m)
 Close and reopen a mailbox.
 
static bool mbox_has_new (struct Mailbox *m)
 Does the mailbox have new mail.
 
void mbox_reset_atime (struct Mailbox *m, struct stat *st)
 Reset the access time on the mailbox file.
 
static bool mbox_ac_owns_path (struct Account *a, const char *path)
 Check whether an Account owns a Mailbox path - Implements MxOps::ac_owns_path() -.
 
static bool mbox_ac_add (struct Account *a, struct Mailbox *m)
 Add a Mailbox to an Account - Implements MxOps::ac_add() -.
 
static FILE * mbox_open_readwrite (struct Mailbox *m)
 Open an mbox read-write.
 
static FILE * mbox_open_readonly (struct Mailbox *m)
 Open an mbox read-only.
 
static enum MxOpenReturns mbox_mbox_open (struct Mailbox *m)
 Open a Mailbox - Implements MxOps::mbox_open() -.
 
static bool mbox_mbox_open_append (struct Mailbox *m, OpenMailboxFlags flags)
 Open a Mailbox for appending - Implements MxOps::mbox_open_append() -.
 
static enum MxStatus mbox_mbox_check (struct Mailbox *m)
 Check for new mail - Implements MxOps::mbox_check() -.
 
static enum MxStatus mbox_mbox_sync (struct Mailbox *m)
 Save changes to the Mailbox - Implements MxOps::mbox_sync() -.
 
static enum MxStatus mbox_mbox_close (struct Mailbox *m)
 Close a Mailbox - Implements MxOps::mbox_close() -.
 
static bool mbox_msg_open (struct Mailbox *m, struct Message *msg, struct Email *e)
 Open an email message in a Mailbox - Implements MxOps::msg_open() -.
 
static bool mbox_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() -.
 
static int mbox_msg_commit (struct Mailbox *m, struct Message *msg)
 Save changes to an email - Implements MxOps::msg_commit() -.
 
static int mbox_msg_close (struct Mailbox *m, struct Message *msg)
 Close an email - Implements MxOps::msg_close() -.
 
static int mbox_msg_padding_size (struct Mailbox *m)
 Bytes of padding between messages - Implements MxOps::msg_padding_size() -.
 
enum MailboxType mbox_path_probe (const char *path, const struct stat *st)
 Is this an mbox Mailbox? - Implements MxOps::path_probe() -.
 
static int mbox_path_canon (struct Buffer *path)
 Canonicalise a Mailbox path - Implements MxOps::path_canon() -.
 
static int mbox_path_is_empty (struct Buffer *path)
 Is the mailbox empty - Implements MxOps::path_is_empty() -.
 
static int mmdf_msg_commit (struct Mailbox *m, struct Message *msg)
 Save changes to an email - Implements MxOps::msg_commit() -.
 
static int mmdf_msg_padding_size (struct Mailbox *m)
 Bytes of padding between messages - Implements MxOps::msg_padding_size() -.
 
static enum MxStatus mbox_mbox_check_stats (struct Mailbox *m, uint8_t flags)
 Check the Mailbox statistics - Implements MxOps::mbox_check_stats() -.
 

Variables

const struct MxOps MxMboxOps
 Mbox Mailbox - Implements MxOps -.
 
const struct MxOps MxMmdfOps
 MMDF Mailbox - Implements MxOps -.
 

Detailed Description

Mbox local mailbox type.

Authors
  • Richard Russon
  • Austin Ray
  • Ian Zimmerman
  • 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 mbox.c.

Function Documentation

◆ mbox_adata_new()

static struct MboxAccountData * mbox_adata_new ( void  )
static

Create a new MboxAccountData struct.

Return values
ptrNew MboxAccountData

Definition at line 93 of file mbox.c.

94{
95 return mutt_mem_calloc(1, sizeof(struct MboxAccountData));
96}
void * mutt_mem_calloc(size_t nmemb, size_t size)
Allocate zeroed memory on the heap.
Definition: memory.c:50
Mbox-specific Account data -.
Definition: lib.h:49
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ init_mailbox()

static int init_mailbox ( struct Mailbox m)
static

Add Mbox data to the Mailbox.

Parameters
mMailbox
Return values
0Success
-1Error Bad format

Definition at line 104 of file mbox.c.

105{
106 if (!m || !m->account)
107 return -1;
108 if ((m->type != MUTT_MBOX) && (m->type != MUTT_MMDF))
109 return -1;
110 if (m->account->adata)
111 return 0;
112
115 return 0;
116}
@ MUTT_MMDF
'mmdf' Mailbox type
Definition: mailbox.h:46
@ MUTT_MBOX
'mbox' Mailbox type
Definition: mailbox.h:45
static void mbox_adata_free(void **ptr)
Free the private Account data - Implements Account::adata_free() -.
Definition: mbox.c:78
static struct MboxAccountData * mbox_adata_new(void)
Create a new MboxAccountData struct.
Definition: mbox.c:93
void(* adata_free)(void **ptr)
Definition: account.h:53
void * adata
Private data (for Mailbox backends)
Definition: account.h:42
enum MailboxType type
Mailbox type.
Definition: mailbox.h:102
struct Account * account
Account that owns this Mailbox.
Definition: mailbox.h:127
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mbox_adata_get()

static struct MboxAccountData * mbox_adata_get ( struct Mailbox m)
static

Get the private data associated with a Mailbox.

Parameters
mMailbox
Return values
ptrPrivate data

Definition at line 123 of file mbox.c.

124{
125 if (init_mailbox(m) == -1)
126 return NULL;
127 return m->account->adata;
128}
static int init_mailbox(struct Mailbox *m)
Add Mbox data to the Mailbox.
Definition: mbox.c:104
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mbox_lock_mailbox()

static int mbox_lock_mailbox ( struct Mailbox m,
bool  excl,
bool  retry 
)
static

Lock a mailbox.

Parameters
mMailbox to lock
exclExclusive lock?
retryShould retry if unable to lock?
Return values
0Success
-1Failure

Definition at line 138 of file mbox.c.

139{
141 if (!adata)
142 return -1;
143
144 int rc = mutt_file_lock(fileno(adata->fp), excl, retry);
145 if (rc == 0)
146 {
147 adata->locked = true;
148 }
149 else if (retry && !excl)
150 {
151 m->readonly = true;
152 return 0;
153 }
154
155 return rc;
156}
int mutt_file_lock(int fd, bool excl, bool timeout)
(Try to) Lock a file using fcntl()
Definition: file.c:1199
static struct MboxAccountData * mbox_adata_get(struct Mailbox *m)
Get the private data associated with a Mailbox.
Definition: mbox.c:123
bool readonly
Don't allow changes to the mailbox.
Definition: mailbox.h:116
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mbox_unlock_mailbox()

static void mbox_unlock_mailbox ( struct Mailbox m)
static

Unlock a mailbox.

Parameters
mMailbox to unlock

Definition at line 162 of file mbox.c.

163{
165 if (!adata)
166 return;
167
168 if (adata->locked)
169 {
170 fflush(adata->fp);
171
172 mutt_file_unlock(fileno(adata->fp));
173 adata->locked = false;
174 }
175}
int mutt_file_unlock(int fd)
Unlock a file previously locked by mutt_file_lock()
Definition: file.c:1246
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mmdf_parse_mailbox()

static enum MxOpenReturns mmdf_parse_mailbox ( struct Mailbox m)
static

Read a mailbox in MMDF format.

Parameters
mMailbox
Return values
enumMxOpenReturns

Definition at line 182 of file mbox.c.

183{
184 if (!m)
185 return MX_OPEN_ERROR;
186
188 if (!adata)
189 return MX_OPEN_ERROR;
190
191 char buf[8192] = { 0 };
192 char return_path[1024] = { 0 };
193 int count = 0;
194 int lines;
195 time_t t = 0;
196 LOFF_T loc, tmploc;
197 struct Email *e = NULL;
198 struct stat st = { 0 };
199 struct Progress *progress = NULL;
201
202 if (stat(mailbox_path(m), &st) == -1)
203 {
204 mutt_perror("%s", mailbox_path(m));
205 goto fail;
206 }
209 m->size = st.st_size;
210
211 buf[sizeof(buf) - 1] = '\0';
212
213 if (m->verbose)
214 {
215 progress = progress_new(MUTT_PROGRESS_READ, 0);
216 progress_set_message(progress, _("Reading %s..."), mailbox_path(m));
217 }
218
219 while (true)
220 {
221 if (!fgets(buf, sizeof(buf) - 1, adata->fp))
222 break;
223
224 if (SigInt)
225 break;
226
227 if (mutt_str_equal(buf, MMDF_SEP))
228 {
229 loc = ftello(adata->fp);
230 if (loc < 0)
231 goto fail;
232
233 count++;
234 progress_update(progress, count, (int) (loc / (m->size / 100 + 1)));
235
237 e = email_new();
238 m->emails[m->msg_count] = e;
239 e->offset = loc;
240 e->index = m->msg_count;
241
242 if (!fgets(buf, sizeof(buf) - 1, adata->fp))
243 {
244 /* TODO: memory leak??? */
245 mutt_debug(LL_DEBUG1, "unexpected EOF\n");
246 break;
247 }
248
249 return_path[0] = '\0';
250
251 if (!is_from(buf, return_path, sizeof(return_path), &t))
252 {
253 if (!mutt_file_seek(adata->fp, loc, SEEK_SET))
254 {
255 mutt_error(_("Mailbox is corrupt"));
256 goto fail;
257 }
258 }
259 else
260 {
261 e->received = t - mutt_date_local_tz(t);
262 }
263
264 e->env = mutt_rfc822_read_header(adata->fp, e, false, false);
265
266 loc = ftello(adata->fp);
267 if (loc < 0)
268 goto fail;
269
270 if ((e->body->length > 0) && (e->lines > 0))
271 {
272 tmploc = loc + e->body->length;
273
274 if ((tmploc > 0) && (tmploc < m->size))
275 {
276 if (!mutt_file_seek(adata->fp, tmploc, SEEK_SET) ||
277 !fgets(buf, sizeof(buf) - 1, adata->fp) || !mutt_str_equal(MMDF_SEP, buf))
278 {
279 (void) mutt_file_seek(adata->fp, loc, SEEK_SET);
280 e->body->length = -1;
281 }
282 }
283 else
284 {
285 e->body->length = -1;
286 }
287 }
288 else
289 {
290 e->body->length = -1;
291 }
292
293 if (e->body->length < 0)
294 {
295 lines = -1;
296 do
297 {
298 loc = ftello(adata->fp);
299 if (loc < 0)
300 goto fail;
301 if (!fgets(buf, sizeof(buf) - 1, adata->fp))
302 break;
303 lines++;
304 } while (!mutt_str_equal(buf, MMDF_SEP));
305
306 e->lines = lines;
307 e->body->length = loc - e->body->offset;
308 }
309
310 if (TAILQ_EMPTY(&e->env->return_path) && return_path[0])
311 mutt_addrlist_parse(&e->env->return_path, return_path);
312
313 if (TAILQ_EMPTY(&e->env->from))
314 mutt_addrlist_copy(&e->env->from, &e->env->return_path, false);
315
316 m->msg_count++;
317 }
318 else
319 {
320 mutt_debug(LL_DEBUG1, "corrupt mailbox\n");
321 mutt_error(_("Mailbox is corrupt"));
322 goto fail;
323 }
324 }
325
326 if (SigInt)
327 {
328 SigInt = false;
329 rc = MX_OPEN_ABORT; /* action aborted */
330 goto fail;
331 }
332
333 rc = MX_OPEN_OK;
334fail:
335 progress_free(&progress);
336 return rc;
337}
void mutt_addrlist_copy(struct AddressList *dst, const struct AddressList *src, bool prune)
Copy a list of addresses into another list.
Definition: address.c:765
int mutt_addrlist_parse(struct AddressList *al, const char *s)
Parse a list of email addresses.
Definition: address.c:480
static const char * mailbox_path(const struct Mailbox *m)
Get the Mailbox's path string.
Definition: mailbox.h:223
struct Email * email_new(void)
Create a new Email.
Definition: email.c:80
struct Envelope * mutt_rfc822_read_header(FILE *fp, struct Email *e, bool user_hdrs, bool weed)
Parses an RFC822 header.
Definition: parse.c:1200
void mutt_file_get_stat_timespec(struct timespec *dest, struct stat *st, enum MuttStatType type)
Read the stat() time into a time value.
Definition: file.c:1576
bool mutt_file_seek(FILE *fp, LOFF_T offset, int whence)
Wrapper for fseeko with error handling.
Definition: file.c:775
@ MUTT_STAT_ATIME
File/dir's atime - last accessed time.
Definition: file.h:64
@ MUTT_STAT_MTIME
File/dir's mtime - last modified time.
Definition: file.h:65
bool is_from(const char *s, char *path, size_t pathlen, time_t *tp)
Is a string a 'From' header line?
Definition: from.c:49
#define mutt_error(...)
Definition: logging2.h:92
#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
#define MMDF_SEP
Definition: lib.h:62
int mutt_date_local_tz(time_t t)
Calculate the local timezone in seconds east of UTC.
Definition: date.c:218
#define _(a)
Definition: message.h:28
bool mutt_str_equal(const char *a, const char *b)
Compare two strings.
Definition: string.c:709
void mx_alloc_memory(struct Mailbox *m, int req_size)
Create storage for the emails.
Definition: mx.c:1204
MxOpenReturns
Return values for mbox_open()
Definition: mxapi.h:76
@ MX_OPEN_ERROR
Open failed with an error.
Definition: mxapi.h:78
@ MX_OPEN_ABORT
Open was aborted.
Definition: mxapi.h:79
@ MX_OPEN_OK
Open succeeded.
Definition: mxapi.h:77
@ MUTT_PROGRESS_READ
Progress tracks elements, according to $read_inc
Definition: lib.h:82
struct Progress * progress_new(enum ProgressType type, size_t size)
Create a new Progress Bar.
Definition: progress.c:139
void progress_free(struct Progress **ptr)
Free a Progress Bar.
Definition: progress.c:110
void progress_set_message(struct Progress *progress, const char *fmt,...) __attribute__((__format__(__printf__
bool progress_update(struct Progress *progress, size_t pos, int percent)
Update the state of the progress bar.
Definition: progress.c:80
#define TAILQ_EMPTY(head)
Definition: queue.h:721
volatile sig_atomic_t SigInt
true after SIGINT is received
Definition: signal.c:63
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
The envelope/body of an email.
Definition: email.h:39
struct Envelope * env
Envelope information.
Definition: email.h:68
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
LOFF_T offset
Where in the stream does this message begin?
Definition: email.h:71
int index
The absolute (unsorted) message number.
Definition: email.h:113
time_t received
Time when the message was placed in the mailbox.
Definition: email.h:61
struct AddressList return_path
Return path for the Email.
Definition: envelope.h:58
struct AddressList from
Email's 'From' list.
Definition: envelope.h:59
int msg_count
Total number of messages.
Definition: mailbox.h:88
struct Email ** emails
Array of Emails.
Definition: mailbox.h:96
off_t size
Size of the Mailbox.
Definition: mailbox.h:84
bool verbose
Display status messages?
Definition: mailbox.h:117
FILE * fp
Mailbox file.
Definition: lib.h:50
struct timespec atime
File's last-access time.
Definition: lib.h:52
struct timespec mtime
Time Mailbox was last changed.
Definition: lib.h:51
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mbox_parse_mailbox()

static enum MxOpenReturns mbox_parse_mailbox ( struct Mailbox m)
static

Read a mailbox from disk.

Parameters
mMailbox
Return values
enumMxOpenReturns

Note that this function is also called when new mail is appended to the currently open folder, and NOT just when the mailbox is initially read.

Note
It is assumed that the mailbox being read has been locked before this routine gets called. Strange things could happen if it's not!

Definition at line 350 of file mbox.c.

351{
352 if (!m)
353 return MX_OPEN_ERROR;
354
356 if (!adata)
357 return MX_OPEN_ERROR;
358
359 struct stat st = { 0 };
360 char buf[8192] = { 0 };
361 char return_path[256] = { 0 };
362 struct Email *e_cur = NULL;
363 time_t t = 0;
364 int count = 0, lines = 0;
365 LOFF_T loc;
366 struct Progress *progress = NULL;
368
369 /* Save information about the folder at the time we opened it. */
370 if (stat(mailbox_path(m), &st) == -1)
371 {
372 mutt_perror("%s", mailbox_path(m));
373 goto fail;
374 }
375
376 m->size = st.st_size;
379
380 if (!m->readonly)
381 m->readonly = access(mailbox_path(m), W_OK) ? true : false;
382
383 if (m->verbose)
384 {
385 progress = progress_new(MUTT_PROGRESS_READ, 0);
386 progress_set_message(progress, _("Reading %s..."), mailbox_path(m));
387 }
388
389 loc = ftello(adata->fp);
390 if (loc < 0)
391 {
392 mutt_debug(LL_DEBUG1, "ftello: %s (errno %d)\n", strerror(errno), errno);
393 loc = 0;
394 }
395
396 while ((fgets(buf, sizeof(buf), adata->fp)) && !SigInt)
397 {
398 if (is_from(buf, return_path, sizeof(return_path), &t))
399 {
400 /* Save the Content-Length of the previous message */
401 if (count > 0)
402 {
403 struct Email *e = m->emails[m->msg_count - 1];
404 if (e->body->length < 0)
405 {
406 e->body->length = loc - e->body->offset - 1;
407 if (e->body->length < 0)
408 e->body->length = 0;
409 }
410 if (e->lines == 0)
411 e->lines = lines ? lines - 1 : 0;
412 }
413
414 count++;
415
416 progress_update(progress, count, (int) (ftello(adata->fp) / (m->size / 100 + 1)));
417
419
420 m->emails[m->msg_count] = email_new();
421 e_cur = m->emails[m->msg_count];
422 e_cur->received = t - mutt_date_local_tz(t);
423 e_cur->offset = loc;
424 e_cur->index = m->msg_count;
425
426 e_cur->env = mutt_rfc822_read_header(adata->fp, e_cur, false, false);
427
428 /* if we know how long this message is, either just skip over the body,
429 * or if we don't know how many lines there are, count them now (this will
430 * save time by not having to search for the next message marker). */
431 if (e_cur->body->length > 0)
432 {
433 LOFF_T tmploc;
434
435 loc = ftello(adata->fp);
436 if (loc < 0)
437 {
438 mutt_debug(LL_DEBUG1, "ftello: %s (errno %d)\n", strerror(errno), errno);
439 loc = 0;
440 }
441
442 /* The test below avoids a potential integer overflow if the
443 * content-length is huge (thus necessarily invalid). */
444 tmploc = (e_cur->body->length < m->size) ? (loc + e_cur->body->length + 1) : -1;
445
446 if ((tmploc > 0) && (tmploc < m->size))
447 {
448 /* check to see if the content-length looks valid. we expect to
449 * to see a valid message separator at this point in the stream */
450 if (!mutt_file_seek(adata->fp, tmploc, SEEK_SET) ||
451 !fgets(buf, sizeof(buf), adata->fp) || !mutt_str_startswith(buf, "From "))
452 {
453 mutt_debug(LL_DEBUG1, "bad content-length in message %d (cl=" OFF_T_FMT ")\n",
454 e_cur->index, e_cur->body->length);
455 mutt_debug(LL_DEBUG1, " LINE: %s", buf);
456 /* nope, return the previous position */
457 (void) mutt_file_seek(adata->fp, loc, SEEK_SET);
458 e_cur->body->length = -1;
459 }
460 }
461 else if (tmploc != m->size)
462 {
463 /* content-length would put us past the end of the file, so it
464 * must be wrong */
465 e_cur->body->length = -1;
466 }
467
468 if (e_cur->body->length != -1)
469 {
470 /* good content-length. check to see if we know how many lines
471 * are in this message. */
472 if (e_cur->lines == 0)
473 {
474 int cl = e_cur->body->length;
475
476 /* count the number of lines in this message */
477 (void) mutt_file_seek(adata->fp, loc, SEEK_SET);
478 while (cl-- > 0)
479 {
480 if (fgetc(adata->fp) == '\n')
481 e_cur->lines++;
482 }
483 }
484
485 /* return to the offset of the next message separator */
486 (void) mutt_file_seek(adata->fp, tmploc, SEEK_SET);
487 }
488 }
489
490 m->msg_count++;
491
492 if (TAILQ_EMPTY(&e_cur->env->return_path) && return_path[0])
493 {
494 mutt_addrlist_parse(&e_cur->env->return_path, return_path);
495 }
496
497 if (TAILQ_EMPTY(&e_cur->env->from))
498 mutt_addrlist_copy(&e_cur->env->from, &e_cur->env->return_path, false);
499
500 lines = 0;
501 }
502 else
503 {
504 lines++;
505 }
506
507 loc = ftello(adata->fp);
508 }
509
510 /* Only set the content-length of the previous message if we have read more
511 * than one message during _this_ invocation. If this routine is called
512 * when new mail is received, we need to make sure not to clobber what
513 * previously was the last message since the headers may be sorted. */
514 if (count > 0)
515 {
516 struct Email *e = m->emails[m->msg_count - 1];
517 if (e->body->length < 0)
518 {
519 e->body->length = ftello(adata->fp) - e->body->offset - 1;
520 if (e->body->length < 0)
521 e->body->length = 0;
522 }
523
524 if (e->lines == 0)
525 e->lines = lines ? lines - 1 : 0;
526 }
527
528 if (SigInt)
529 {
530 SigInt = false;
531 rc = MX_OPEN_ABORT;
532 goto fail; /* action aborted */
533 }
534
535 rc = MX_OPEN_OK;
536fail:
537 progress_free(&progress);
538 return rc;
539}
size_t mutt_str_startswith(const char *str, const char *prefix)
Check whether a string starts with a prefix.
Definition: string.c:230
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ reopen_mailbox()

static int reopen_mailbox ( struct Mailbox m)
static

Close and reopen a mailbox.

Parameters
mMailbox
Return values
>0Success, e.g. MX_STATUS_REOPENED, MX_STATUS_NEW_MAIL
-1Error

Definition at line 547 of file mbox.c.

548{
549 if (!m)
550 return -1;
551
553 if (!adata)
554 return -1;
555
556 bool (*cmp_headers)(const struct Email *, const struct Email *) = NULL;
557 struct Email **e_old = NULL;
558 int old_msg_count;
559 bool msg_mod = false;
560 int rc = -1;
561
562 /* silent operations */
563 m->verbose = false;
564
565 /* our heuristics require the old mailbox to be unsorted */
566 const enum SortType c_sort = cs_subset_sort(NeoMutt->sub, "sort");
567 if (c_sort != SORT_ORDER)
568 {
571 cs_subset_str_native_set(NeoMutt->sub, "sort", c_sort, NULL);
572 }
573
574 e_old = NULL;
575 old_msg_count = 0;
576
577 /* simulate a close */
581 FREE(&m->v2r);
582 if (m->readonly)
583 {
584 for (int i = 0; i < m->msg_count; i++)
585 email_free(&(m->emails[i])); /* nothing to do! */
586 FREE(&m->emails);
587 }
588 else
589 {
590 /* save the old headers */
591 old_msg_count = m->msg_count;
592 e_old = m->emails;
593 m->emails = NULL;
594 }
595
596 m->email_max = 0; /* force allocation of new headers */
597 m->msg_count = 0;
598 m->vcount = 0;
599 m->msg_tagged = 0;
600 m->msg_deleted = 0;
601 m->msg_new = 0;
602 m->msg_unread = 0;
603 m->msg_flagged = 0;
604 m->changed = false;
605 m->id_hash = NULL;
606 m->subj_hash = NULL;
608
609 switch (m->type)
610 {
611 case MUTT_MBOX:
612 case MUTT_MMDF:
613 cmp_headers = email_cmp_strict;
614 mutt_file_fclose(&adata->fp);
615 adata->fp = mutt_file_fopen(mailbox_path(m), "r");
616 if (!adata->fp)
617 rc = -1;
618 else if (m->type == MUTT_MBOX)
619 rc = mbox_parse_mailbox(m);
620 else
621 rc = mmdf_parse_mailbox(m);
622 break;
623
624 default:
625 rc = -1;
626 break;
627 }
628
629 if (rc == -1)
630 {
631 /* free the old headers */
632 for (int i = 0; i < old_msg_count; i++)
633 email_free(&(e_old[i]));
634 FREE(&e_old);
635
636 m->verbose = true;
637 return -1;
638 }
639
640 mutt_file_touch_atime(fileno(adata->fp));
641
642 /* now try to recover the old flags */
643
644 if (!m->readonly)
645 {
646 for (int i = 0; i < m->msg_count; i++)
647 {
648 bool found = false;
649
650 /* some messages have been deleted, and new messages have been
651 * appended at the end; the heuristic is that old messages have then
652 * "advanced" towards the beginning of the folder, so we begin the
653 * search at index "i" */
654 int j;
655 for (j = i; j < old_msg_count; j++)
656 {
657 if (!e_old[j])
658 continue;
659 if (cmp_headers(m->emails[i], e_old[j]))
660 {
661 found = true;
662 break;
663 }
664 }
665 if (!found)
666 {
667 for (j = 0; (j < i) && (j < old_msg_count); j++)
668 {
669 if (!e_old[j])
670 continue;
671 if (cmp_headers(m->emails[i], e_old[j]))
672 {
673 found = true;
674 break;
675 }
676 }
677 }
678
679 if (found)
680 {
681 m->changed = true;
682 if (e_old[j]->changed)
683 {
684 /* Only update the flags if the old header was changed;
685 * otherwise, the header may have been modified externally,
686 * and we don't want to lose _those_ changes */
687 mutt_set_flag(m, m->emails[i], MUTT_FLAG, e_old[j]->flagged, true);
688 mutt_set_flag(m, m->emails[i], MUTT_REPLIED, e_old[j]->replied, true);
689 mutt_set_flag(m, m->emails[i], MUTT_OLD, e_old[j]->old, true);
690 mutt_set_flag(m, m->emails[i], MUTT_READ, e_old[j]->read, true);
691 }
692 mutt_set_flag(m, m->emails[i], MUTT_DELETE, e_old[j]->deleted, true);
693 mutt_set_flag(m, m->emails[i], MUTT_PURGE, e_old[j]->purge, true);
694 mutt_set_flag(m, m->emails[i], MUTT_TAG, e_old[j]->tagged, true);
695
696 /* we don't need this header any more */
697 email_free(&(e_old[j]));
698 }
699 }
700
701 /* free the remaining old emails */
702 for (int j = 0; j < old_msg_count; j++)
703 {
704 if (e_old[j])
705 {
706 email_free(&(e_old[j]));
707 msg_mod = true;
708 }
709 }
710 FREE(&e_old);
711 }
712
714 m->verbose = true;
715
716 return (m->changed || msg_mod) ? MX_STATUS_REOPENED : MX_STATUS_NEW_MAIL;
717}
short cs_subset_sort(const struct ConfigSubset *sub, const char *name)
Get a sort config item by name.
Definition: helpers.c:267
void mailbox_changed(struct Mailbox *m, enum NotifyMailbox action)
Notify observers of a change to a Mailbox.
Definition: mailbox.c:234
@ NT_MAILBOX_RESORT
Email list needs resorting.
Definition: mailbox.h:190
@ NT_MAILBOX_UPDATE
Update internal tables.
Definition: mailbox.h:191
bool email_cmp_strict(const struct Email *e1, const struct Email *e2)
Strictly compare message emails.
Definition: email.c:102
void email_free(struct Email **ptr)
Free an Email.
Definition: email.c:46
void mutt_file_touch_atime(int fd)
Set the access time to current time.
Definition: file.c:1088
#define mutt_file_fclose(FP)
Definition: file.h:147
#define mutt_file_fopen(PATH, MODE)
Definition: file.h:146
void mutt_set_flag(struct Mailbox *m, struct Email *e, enum MessageType flag, bool bf, bool upd_mbox)
Set a flag on an email.
Definition: flags.c:57
void mutt_hash_free(struct HashTable **ptr)
Free a hash table.
Definition: hash.c:457
static enum MxOpenReturns mbox_parse_mailbox(struct Mailbox *m)
Read a mailbox from disk.
Definition: mbox.c:350
static enum MxOpenReturns mmdf_parse_mailbox(struct Mailbox *m)
Read a mailbox in MMDF format.
Definition: mbox.c:182
#define FREE(x)
Definition: memory.h:45
@ MUTT_READ
Messages that have been read.
Definition: mutt.h:73
@ MUTT_OLD
Old messages.
Definition: mutt.h:71
@ MUTT_PURGE
Messages to be purged (bypass trash)
Definition: mutt.h:77
@ MUTT_TAG
Tagged messages.
Definition: mutt.h:80
@ MUTT_FLAG
Flagged messages.
Definition: mutt.h:79
@ MUTT_DELETE
Messages to be deleted.
Definition: mutt.h:75
@ MUTT_REPLIED
Messages that have been replied to.
Definition: mutt.h:72
void mutt_make_label_hash(struct Mailbox *m)
Create a Hash Table to store the labels.
Definition: mutt_header.c:419
@ MX_STATUS_REOPENED
Mailbox was reopened.
Definition: mxapi.h:68
@ MX_STATUS_NEW_MAIL
New mail received in Mailbox.
Definition: mxapi.h:66
SortType
Methods for sorting.
Definition: sort2.h:34
@ SORT_ORDER
Sort by the order the messages appear in the mailbox.
Definition: sort2.h:40
bool changed
Email has been edited.
Definition: email.h:77
int vcount
The number of virtual messages.
Definition: mailbox.h:99
bool changed
Mailbox has been modified.
Definition: mailbox.h:110
int * v2r
Mapping from virtual to real msgno.
Definition: mailbox.h:98
int msg_new
Number of new messages.
Definition: mailbox.h:92
int email_max
Size of emails array.
Definition: mailbox.h:97
struct HashTable * subj_hash
Hash Table: "subject" -> Email.
Definition: mailbox.h:124
struct HashTable * id_hash
Hash Table: "message-id" -> Email.
Definition: mailbox.h:123
int msg_deleted
Number of deleted messages.
Definition: mailbox.h:93
struct HashTable * label_hash
Hash Table: "x-labels" -> Email.
Definition: mailbox.h:125
int msg_flagged
Number of flagged messages.
Definition: mailbox.h:90
int msg_tagged
How many messages are tagged?
Definition: mailbox.h:94
int msg_unread
Number of unread messages.
Definition: mailbox.h:89
Container for Accounts, Notifications.
Definition: neomutt.h:41
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:45
int cs_subset_str_native_set(const struct ConfigSubset *sub, const char *name, intptr_t value, struct Buffer *err)
Natively set the value of a string config item.
Definition: subset.c:297
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mbox_has_new()

static bool mbox_has_new ( struct Mailbox m)
static

Does the mailbox have new mail.

Parameters
mMailbox
Return values
trueThe mailbox has at least 1 new messages (not old)
falseotherwise

Definition at line 725 of file mbox.c.

726{
727 for (int i = 0; i < m->msg_count; i++)
728 {
729 struct Email *e = m->emails[i];
730 if (!e)
731 break;
732 if (!e->deleted && !e->read && !e->old)
733 return true;
734 }
735 return false;
736}
bool read
Email is read.
Definition: email.h:50
bool old
Email is seen, but unread.
Definition: email.h:49
bool deleted
Email is deleted.
Definition: email.h:78
+ Here is the caller graph for this function:

◆ mbox_reset_atime()

void mbox_reset_atime ( struct Mailbox m,
struct stat *  st 
)

Reset the access time on the mailbox file.

Parameters
mMailbox
stTimestamp

if mailbox has at least 1 new message, sets mtime > atime of mailbox so mailbox check reports new mail

Definition at line 746 of file mbox.c.

747{
748 struct stat st2 = { 0 };
749 if (!st)
750 {
751 if (stat(mailbox_path(m), &st2) < 0)
752 return;
753 st = &st2;
754 }
755
756 struct utimbuf utimebuf = { 0 };
757 utimebuf.actime = st->st_atime;
758 utimebuf.modtime = st->st_mtime;
759
760 /* When $mbox_check_recent is set, existing new mail is ignored, so do not
761 * reset the atime to mtime-1 to signal new mail. */
762 const bool c_mail_check_recent = cs_subset_bool(NeoMutt->sub, "mail_check_recent");
763 if (!c_mail_check_recent && (utimebuf.actime >= utimebuf.modtime) && mbox_has_new(m))
764 {
765 utimebuf.actime = utimebuf.modtime - 1;
766 }
767
768 utime(mailbox_path(m), &utimebuf);
769}
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:48
static bool mbox_has_new(struct Mailbox *m)
Does the mailbox have new mail.
Definition: mbox.c:725
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mbox_open_readwrite()

static FILE * mbox_open_readwrite ( struct Mailbox m)
static

Open an mbox read-write.

Parameters
mMailbox
Return values
ptrFILE handle

This function ensures that the FILE and readonly flag are changed atomically.

Definition at line 801 of file mbox.c.

802{
803 FILE *fp = mutt_file_fopen(mailbox_path(m), "r+");
804 if (fp)
805 m->readonly = false;
806 return fp;
807}
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mbox_open_readonly()

static FILE * mbox_open_readonly ( struct Mailbox m)
static

Open an mbox read-only.

Parameters
mMailbox
Return values
ptrFILE handle

This function ensures that the FILE and readonly flag are changed atomically.

Definition at line 816 of file mbox.c.

817{
818 FILE *fp = mutt_file_fopen(mailbox_path(m), "r");
819 if (fp)
820 m->readonly = true;
821 return fp;
822}
+ Here is the call graph for this function:
+ Here is the caller graph for this function: