NeoMutt  2024-04-25-97-g7d2481
Teaching an old dog new tricks
DOXYGEN
Loading...
Searching...
No Matches
mutt_mailbox.c
Go to the documentation of this file.
1
31#include "config.h"
32#include <string.h>
33#include <sys/stat.h>
34#include <sys/types.h>
35#include <utime.h>
36#include "mutt/lib.h"
37#include "config/lib.h"
38#include "core/lib.h"
39#include "mutt_mailbox.h"
40#include "postpone/lib.h"
41#include "muttlib.h"
42#include "mx.h"
43
44static time_t MailboxTime = 0;
45static time_t MailboxStatsTime = 0;
46static short MailboxCount = 0;
47static short MailboxNotify = 0;
48
58static bool is_same_mailbox(struct Mailbox *m1, struct Mailbox *m2,
59 struct stat *st1, struct stat *st2)
60{
61 if (!m1 || buf_is_empty(&m1->pathbuf) || !m2 || buf_is_empty(&m2->pathbuf) ||
62 (m1->type != m2->type))
63 {
64 return false;
65 }
66
67 const bool uses_protocol = (m2->type == MUTT_IMAP) || (m2->type == MUTT_NNTP) ||
68 (m2->type == MUTT_NOTMUCH) || (m2->type == MUTT_POP);
69
70 if (uses_protocol)
72 else
73 return ((st1->st_dev == st2->st_dev) && (st1->st_ino == st2->st_ino));
74}
75
83static void mailbox_check(struct Mailbox *m_cur, struct Mailbox *m_check,
84 struct stat *st_cur, CheckStatsFlags flags)
85{
86 struct stat st = { 0 };
87
88 enum MailboxType mb_type = mx_path_probe(mailbox_path(m_check));
89
90 const bool c_mail_check_recent = cs_subset_bool(NeoMutt->sub, "mail_check_recent");
91 if ((m_cur == m_check) && c_mail_check_recent)
92 m_check->has_new = false;
93
94 switch (mb_type)
95 {
96 case MUTT_POP:
97 case MUTT_NNTP:
98 case MUTT_NOTMUCH:
99 case MUTT_IMAP:
100 m_check->type = mb_type;
101 break;
102 default:
103 if ((stat(mailbox_path(m_check), &st) != 0) ||
104 ((m_check->type == MUTT_UNKNOWN) && S_ISREG(st.st_mode) && (st.st_size == 0)) ||
105 ((m_check->type == MUTT_UNKNOWN) &&
106 ((m_check->type = mx_path_probe(mailbox_path(m_check))) <= 0)))
107 {
108 /* if the mailbox still doesn't exist, set the newly created flag to be
109 * ready for when it does. */
110 m_check->newly_created = true;
111 m_check->type = MUTT_UNKNOWN;
112 m_check->size = 0;
113 return;
114 }
115 break; // kept for consistency.
116 }
117
118 const bool c_check_mbox_size = cs_subset_bool(NeoMutt->sub, "check_mbox_size");
119
120 /* check to see if the folder is the currently selected folder before polling */
121 if (!is_same_mailbox(m_cur, m_check, st_cur, &st))
122 {
123 switch (m_check->type)
124 {
125 case MUTT_NOTMUCH:
126 // Remove this when non-notmuch backends only check unread, flagged,
127 // and total counts per 'mbox_check_stats' docs.
128 if ((flags & MUTT_MAILBOX_CHECK_FORCE_STATS) == 0)
129 break;
131
132 case MUTT_IMAP:
133 case MUTT_MBOX:
134 case MUTT_MMDF:
135 case MUTT_MAILDIR:
136 case MUTT_MH:
137 mx_mbox_check_stats(m_check, flags);
138 break;
139 default:; /* do nothing */
140 }
141 }
142 else if (c_check_mbox_size && m_cur && buf_is_empty(&m_cur->pathbuf))
143 {
144 m_check->size = (off_t) st.st_size; /* update the size of current folder */
145 }
146
147 if (!m_check->has_new)
148 {
149 m_check->notified = false;
150 }
151 else
152 {
153 // pretend that we've already notified for the mailbox
154 if (!m_check->notify_user)
155 m_check->notified = true;
156 else if (!m_check->notified)
158 }
159}
160
170{
171 if (TAILQ_EMPTY(&NeoMutt->accounts)) // fast return if there are no mailboxes
172 return 0;
173
174 if (flags & MUTT_MAILBOX_CHECK_FORCE)
176
177 const short c_mail_check = cs_subset_number(NeoMutt->sub, "mail_check");
178 const bool c_mail_check_stats = cs_subset_bool(NeoMutt->sub, "mail_check_stats");
179 const short c_mail_check_stats_interval = cs_subset_number(NeoMutt->sub, "mail_check_stats_interval");
180
181 time_t t = mutt_date_now();
182 if ((flags == MUTT_MAILBOX_CHECK_NO_FLAGS) && ((t - MailboxTime) < c_mail_check))
183 return MailboxCount;
184
185 if ((flags & MUTT_MAILBOX_CHECK_FORCE_STATS) ||
186 (c_mail_check_stats && ((t - MailboxStatsTime) >= c_mail_check_stats_interval)))
187 {
190 }
191
192 MailboxTime = t;
193 MailboxCount = 0;
194 MailboxNotify = 0;
195
196 /* check device ID and serial number instead of comparing paths */
197 struct stat st_cur = { 0 };
198 if (!m_cur || (m_cur->type == MUTT_IMAP) || (m_cur->type == MUTT_POP) ||
199 (m_cur->type == MUTT_NNTP) || stat(mailbox_path(m_cur), &st_cur) != 0)
200 {
201 st_cur.st_dev = 0;
202 st_cur.st_ino = 0;
203 }
204
205 struct MailboxList ml = STAILQ_HEAD_INITIALIZER(ml);
207 struct MailboxNode *np = NULL;
208 STAILQ_FOREACH(np, &ml, entries)
209 {
210 struct Mailbox *m = np->mailbox;
211
212 if (!m->visible || !m->poll_new_mail)
213 continue;
214
215 CheckStatsFlags m_flags = flags;
216 if (!m->first_check_stats_done && c_mail_check_stats)
217 {
219 }
220 mailbox_check(m_cur, m, &st_cur, m_flags);
221 if (m->has_new)
222 MailboxCount++;
223 m->first_check_stats_done = true;
224 }
226
227 return MailboxCount;
228}
229
235bool mutt_mailbox_notify(struct Mailbox *m_cur)
236{
238 {
239 return mutt_mailbox_list();
240 }
241 return false;
242}
243
249{
250 int have_unnotified = MailboxNotify;
251
252 struct Buffer *path = buf_pool_get();
253 struct Buffer *mailboxlist = buf_pool_get();
254
255 buf_addstr(mailboxlist, _("New mail in "));
256 struct MailboxList ml = STAILQ_HEAD_INITIALIZER(ml);
258 struct MailboxNode *np = NULL;
259 bool any_new = false;
260 STAILQ_FOREACH(np, &ml, entries)
261 {
262 /* Is there new mail in this mailbox? */
263 if (!np->mailbox->has_new || (have_unnotified && np->mailbox->notified))
264 continue;
265
266 buf_strcpy(path, mailbox_path(np->mailbox));
267 buf_pretty_mailbox(path);
268
269 if (any_new)
270 {
271 buf_addstr(mailboxlist, ", ");
272 }
273
274 if (!np->mailbox->notified)
275 {
276 np->mailbox->notified = true;
278 }
279 buf_addstr(mailboxlist, buf_string(path));
280 any_new = true;
281 }
283
284 buf_pool_release(&path);
285
286 if (any_new)
287 {
288 mutt_message("%s", buf_string(mailboxlist));
289 buf_pool_release(&mailboxlist);
290 return true;
291 }
292
293 /* there were no mailboxes needing to be notified, so clean up since
294 * MailboxNotify has somehow gotten out of sync */
295 MailboxNotify = 0;
296 buf_pool_release(&mailboxlist);
297 return false;
298}
299
305{
306 if (!m)
307 return;
308
309 m->notified = true;
311}
312
322static struct Mailbox *find_next_mailbox(struct Buffer *s, bool find_new)
323{
324 bool found = false;
325 for (int pass = 0; pass < 2; pass++)
326 {
327 struct MailboxList ml = STAILQ_HEAD_INITIALIZER(ml);
329 struct MailboxNode *np = NULL;
330 STAILQ_FOREACH(np, &ml, entries)
331 {
333 struct Mailbox *m_cur = np->mailbox;
334
335 if ((found || (pass > 0)) && (find_new ? m_cur->has_new : m_cur->msg_unread > 0))
336 {
339 struct Mailbox *m_result = np->mailbox;
341 return m_result;
342 }
344 found = true;
345 }
347 }
348
349 return NULL;
350}
351
361struct Mailbox *mutt_mailbox_next(struct Mailbox *m_cur, struct Buffer *s)
362{
364
366 {
367 struct Mailbox *m_res = find_next_mailbox(s, true);
368 if (m_res)
369 return m_res;
370
371 mutt_mailbox_check(m_cur, MUTT_MAILBOX_CHECK_FORCE); /* mailbox was wrong - resync things */
372 }
373
374 buf_reset(s); // no folders with new mail
375 return NULL;
376}
377
387struct Mailbox *mutt_mailbox_next_unread(struct Mailbox *m_cur, struct Buffer *s)
388{
390
391 struct Mailbox *m_res = find_next_mailbox(s, false);
392 if (m_res)
393 return m_res;
394
395 buf_reset(s); // no folders with new mail
396 return NULL;
397}
398
407void mailbox_restore_timestamp(const char *path, struct stat *st)
408{
409#ifdef HAVE_UTIMENSAT
410 struct timespec ts[2] = { { 0 }, { 0 } };
411#else
412 struct utimbuf ut = { 0 };
413#endif
414
415 const bool c_check_mbox_size = cs_subset_bool(NeoMutt->sub, "check_mbox_size");
416 if (c_check_mbox_size)
417 {
418 struct Mailbox *m = mailbox_find(path);
419 if (m && !m->has_new)
421 }
422 else
423 {
424 /* fix up the times so mailbox won't get confused */
425 if (st->st_mtime > st->st_atime)
426 {
427#ifdef HAVE_UTIMENSAT
428 ts[0].tv_sec = 0;
429 ts[0].tv_nsec = UTIME_OMIT;
430 ts[1].tv_sec = 0;
431 ts[1].tv_nsec = UTIME_NOW;
432 utimensat(AT_FDCWD, buf, ts, 0);
433#else
434 ut.actime = st->st_atime;
435 ut.modtime = mutt_date_now();
436 utime(path, &ut);
437#endif
438 }
439 else
440 {
441#ifdef HAVE_UTIMENSAT
442 ts[0].tv_sec = 0;
443 ts[0].tv_nsec = UTIME_NOW;
444 ts[1].tv_sec = 0;
445 ts[1].tv_nsec = UTIME_NOW;
446 utimensat(AT_FDCWD, buf, ts, 0);
447#else
448 utime(path, NULL);
449#endif
450 }
451 }
452}
void buf_reset(struct Buffer *buf)
Reset an existing Buffer.
Definition: buffer.c:76
bool buf_is_empty(const struct Buffer *buf)
Is the Buffer empty?
Definition: buffer.c:291
size_t buf_addstr(struct Buffer *buf, const char *s)
Add a string to a Buffer.
Definition: buffer.c:226
size_t buf_strcpy(struct Buffer *buf, const char *s)
Copy a string into a Buffer.
Definition: buffer.c:395
static const char * buf_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:96
short cs_subset_number(const struct ConfigSubset *sub, const char *name)
Get a number config item by name.
Definition: helpers.c:143
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:47
Convenience wrapper for the config headers.
Convenience wrapper for the core headers.
void mailbox_update(struct Mailbox *m)
Get the mailbox's current size.
Definition: mailbox.c:215
struct Mailbox * mailbox_find(const char *path)
Find the mailbox with a given path.
Definition: mailbox.c:150
static const char * mailbox_path(const struct Mailbox *m)
Get the Mailbox's path string.
Definition: mailbox.h:223
MailboxType
Supported mailbox formats.
Definition: mailbox.h:41
@ MUTT_NOTMUCH
'Notmuch' (virtual) Mailbox type
Definition: mailbox.h:51
@ MUTT_MMDF
'mmdf' Mailbox type
Definition: mailbox.h:46
@ MUTT_POP
'POP3' Mailbox type
Definition: mailbox.h:52
@ MUTT_MH
'MH' Mailbox type
Definition: mailbox.h:47
@ MUTT_NNTP
'NNTP' (Usenet) Mailbox type
Definition: mailbox.h:49
@ MUTT_IMAP
'IMAP' Mailbox type
Definition: mailbox.h:50
@ MUTT_MBOX
'mbox' Mailbox type
Definition: mailbox.h:45
@ MUTT_MAILBOX_ANY
Match any Mailbox type.
Definition: mailbox.h:42
@ MUTT_UNKNOWN
Mailbox wasn't recognised.
Definition: mailbox.h:44
@ MUTT_MAILDIR
'Maildir' Mailbox type
Definition: mailbox.h:48
#define mutt_message(...)
Definition: logging2.h:91
time_t mutt_date_now(void)
Return the number of seconds since the Unix epoch.
Definition: date.c:456
void mutt_time_now(struct timespec *tp)
Set the provided time field to the current time.
Definition: date.c:480
Convenience wrapper for the library headers.
#define FALLTHROUGH
Definition: lib.h:111
#define _(a)
Definition: message.h:28
bool mutt_str_equal(const char *a, const char *b)
Compare two strings.
Definition: string.c:660
static time_t MailboxStatsTime
last time we check performed mail_check_stats
Definition: mutt_mailbox.c:45
static short MailboxCount
how many boxes with new mail
Definition: mutt_mailbox.c:46
static short MailboxNotify
Definition: mutt_mailbox.c:47
int mutt_mailbox_check(struct Mailbox *m_cur, CheckStatsFlags flags)
Check all all Mailboxes for new mail.
Definition: mutt_mailbox.c:169
void mutt_mailbox_set_notified(struct Mailbox *m)
Note when the user was last notified of new mail.
Definition: mutt_mailbox.c:304
struct Mailbox * mutt_mailbox_next_unread(struct Mailbox *m_cur, struct Buffer *s)
Find next mailbox with unread mail.
Definition: mutt_mailbox.c:387
bool mutt_mailbox_notify(struct Mailbox *m_cur)
Notify the user if there's new mail.
Definition: mutt_mailbox.c:235
struct Mailbox * mutt_mailbox_next(struct Mailbox *m_cur, struct Buffer *s)
Incoming folders completion routine.
Definition: mutt_mailbox.c:361
bool mutt_mailbox_list(void)
Show a message with the list of mailboxes with new mail.
Definition: mutt_mailbox.c:248
static bool is_same_mailbox(struct Mailbox *m1, struct Mailbox *m2, struct stat *st1, struct stat *st2)
Compare two Mailboxes to see if they're equal.
Definition: mutt_mailbox.c:58
static struct Mailbox * find_next_mailbox(struct Buffer *s, bool find_new)
Find the next mailbox with new or unread mail.
Definition: mutt_mailbox.c:322
static void mailbox_check(struct Mailbox *m_cur, struct Mailbox *m_check, struct stat *st_cur, CheckStatsFlags flags)
Check a mailbox for new mail.
Definition: mutt_mailbox.c:83
static time_t MailboxTime
last time we started checking for mail
Definition: mutt_mailbox.c:44
void mailbox_restore_timestamp(const char *path, struct stat *st)
Restore the timestamp of a mailbox.
Definition: mutt_mailbox.c:407
Mailbox helper functions.
void buf_pretty_mailbox(struct Buffer *buf)
Shorten a mailbox path using '~' or '='.
Definition: muttlib.c:519
void buf_expand_path(struct Buffer *buf)
Create the canonical path.
Definition: muttlib.c:315
Some miscellaneous functions.
enum MxStatus mx_mbox_check_stats(struct Mailbox *m, uint8_t flags)
Check the statistics for a mailbox - Wrapper for MxOps::mbox_check_stats()
Definition: mx.c:1759
enum MailboxType mx_path_probe(const char *path)
Find a mailbox that understands a path.
Definition: mx.c:1321
API for mailboxes.
#define MUTT_MAILBOX_CHECK_NO_FLAGS
No flags are set.
Definition: mxapi.h:53
#define MUTT_MAILBOX_CHECK_FORCE_STATS
Ignore MailboxType and calculate statistics.
Definition: mxapi.h:55
#define MUTT_MAILBOX_CHECK_FORCE
Ignore MailboxTime and check for new mail.
Definition: mxapi.h:54
uint8_t CheckStatsFlags
Flags for mutt_mailbox_check.
Definition: mxapi.h:52
void neomutt_mailboxlist_clear(struct MailboxList *ml)
Free a Mailbox List.
Definition: neomutt.c:168
size_t neomutt_mailboxlist_get_all(struct MailboxList *head, struct NeoMutt *n, enum MailboxType type)
Get a List of all Mailboxes.
Definition: neomutt.c:191
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
Postponed Emails.
void mutt_update_num_postponed(void)
Force the update of the number of postponed messages.
Definition: postpone.c:178
#define STAILQ_HEAD_INITIALIZER(head)
Definition: queue.h:324
#define STAILQ_FOREACH(var, head, field)
Definition: queue.h:352
#define TAILQ_EMPTY(head)
Definition: queue.h:721
String manipulation buffer.
Definition: buffer.h:36
List of Mailboxes.
Definition: mailbox.h:166
struct Mailbox * mailbox
Mailbox in the list.
Definition: mailbox.h:167
A mailbox.
Definition: mailbox.h:79
bool has_new
Mailbox has new mail.
Definition: mailbox.h:85
bool first_check_stats_done
True when the check have been done at least one time.
Definition: mailbox.h:112
enum MailboxType type
Mailbox type.
Definition: mailbox.h:102
bool newly_created
Mbox or mmdf just popped into existence.
Definition: mailbox.h:103
bool poll_new_mail
Check for new mail.
Definition: mailbox.h:115
bool notify_user
Notify the user of new mail.
Definition: mailbox.h:113
struct Buffer pathbuf
Path of the Mailbox.
Definition: mailbox.h:80
bool notified
User has been notified.
Definition: mailbox.h:101
off_t size
Size of the Mailbox.
Definition: mailbox.h:84
bool visible
True if a result of "mailboxes".
Definition: mailbox.h:130
struct timespec last_visited
Time of last exit from this mailbox.
Definition: mailbox.h:104
int msg_unread
Number of unread messages.
Definition: mailbox.h:89
Container for Accounts, Notifications.
Definition: neomutt.h:42
struct AccountList accounts
List of all Accounts.
Definition: neomutt.h:47
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:46
Time value with nanosecond precision.
Definition: file.h:51
long tv_nsec
Number of nanosecond, on top.
Definition: file.h:53
time_t tv_sec
Number of seconds since the epoch.
Definition: file.h:52