NeoMutt  2023-05-17-33-gce4425
Teaching an old dog new tricks
DOXYGEN
mutt_mailbox.c File Reference

Mailbox helper functions. More...

#include "config.h"
#include <string.h>
#include <sys/stat.h>
#include <time.h>
#include <utime.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "core/lib.h"
#include "gui/lib.h"
#include "mutt_mailbox.h"
#include "postpone/lib.h"
#include "muttlib.h"
#include "mx.h"
+ Include dependency graph for mutt_mailbox.c:

Go to the source code of this file.

Functions

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. More...
 
static void mailbox_check (struct Mailbox *m_cur, struct Mailbox *m_check, struct stat *st_ctx, CheckStatsFlags flags)
 Check a mailbox for new mail. More...
 
int mutt_mailbox_check (struct Mailbox *m_cur, CheckStatsFlags flags)
 Check all all Mailboxes for new mail. More...
 
bool mutt_mailbox_notify (struct Mailbox *m_cur)
 Notify the user if there's new mail. More...
 
bool mutt_mailbox_list (void)
 List the mailboxes with new mail. More...
 
void mutt_mailbox_set_notified (struct Mailbox *m)
 Note when the user was last notified of new mail. More...
 
static struct Mailboxfind_next_mailbox (struct Buffer *s, bool find_new)
 Find the next mailbox with new or unread mail. More...
 
struct Mailboxmutt_mailbox_next (struct Mailbox *m_cur, struct Buffer *s)
 Incoming folders completion routine. More...
 
struct Mailboxmutt_mailbox_next_unread (struct Mailbox *m_cur, struct Buffer *s)
 Find next mailbox with unread mail. More...
 
void mutt_mailbox_cleanup (const char *path, struct stat *st)
 Restore the timestamp of a mailbox. More...
 

Variables

static time_t MailboxTime = 0
 last time we started checking for mail More...
 
static time_t MailboxStatsTime = 0
 last time we check performed mail_check_stats More...
 
static short MailboxCount = 0
 how many boxes with new mail More...
 
static short MailboxNotify = 0
 

Detailed Description

Mailbox helper functions.

  • 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 mutt_mailbox.c.

Function Documentation

◆ is_same_mailbox()

static bool is_same_mailbox ( struct Mailbox m1,
struct Mailbox m2,
struct stat *  st1,
struct stat *  st2 
)
static

Compare two Mailboxes to see if they're equal.

Parameters
m1First mailbox
m2Second mailbox
st1stat() info for first mailbox
st2stat() info for second mailbox
Return values
trueMailboxes are the same
falseMailboxes are different

Definition at line 56 of file mutt_mailbox.c.

58{
59 if (!m1 || buf_is_empty(&m1->pathbuf) || !m2 || buf_is_empty(&m2->pathbuf) ||
60 (m1->type != m2->type))
61 {
62 return false;
63 }
64
65 const bool uses_protocol = (m2->type == MUTT_IMAP) || (m2->type == MUTT_NNTP) ||
66 (m2->type == MUTT_NOTMUCH) || (m2->type == MUTT_POP);
67
68 if (uses_protocol)
70 else
71 return ((st1->st_dev == st2->st_dev) && (st1->st_ino == st2->st_ino));
72}
bool buf_is_empty(const struct Buffer *buf)
Is the Buffer empty?
Definition: buffer.c:301
static const char * mailbox_path(const struct Mailbox *m)
Get the Mailbox's path string.
Definition: mailbox.h:209
@ MUTT_NOTMUCH
'Notmuch' (virtual) Mailbox type
Definition: mailbox.h:51
@ MUTT_POP
'POP3' Mailbox type
Definition: mailbox.h:52
@ MUTT_NNTP
'NNTP' (Usenet) Mailbox type
Definition: mailbox.h:49
@ MUTT_IMAP
'IMAP' Mailbox type
Definition: mailbox.h:50
bool mutt_str_equal(const char *a, const char *b)
Compare two strings.
Definition: string.c:798
enum MailboxType type
Mailbox type.
Definition: mailbox.h:102
struct Buffer pathbuf
Path of the Mailbox.
Definition: mailbox.h:80
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mailbox_check()

static void mailbox_check ( struct Mailbox m_cur,
struct Mailbox m_check,
struct stat *  st_ctx,
CheckStatsFlags  flags 
)
static

Check a mailbox for new mail.

Parameters
m_curCurrent Mailbox
m_checkMailbox to check
st_ctxstat() info for the current Mailbox
flagsFlags, e.g. MUTT_MAILBOX_CHECK_FORCE

Definition at line 81 of file mutt_mailbox.c.

83{
84 struct stat st = { 0 };
85
86 enum MailboxType mb_type = mx_path_probe(mailbox_path(m_check));
87
88 const bool c_mail_check_recent = cs_subset_bool(NeoMutt->sub, "mail_check_recent");
89 if ((m_cur == m_check) && c_mail_check_recent)
90 m_check->has_new = false;
91
92 switch (mb_type)
93 {
94 case MUTT_POP:
95 case MUTT_NNTP:
96 case MUTT_NOTMUCH:
97 case MUTT_IMAP:
98 m_check->type = mb_type;
99 break;
100 default:
101 if ((stat(mailbox_path(m_check), &st) != 0) ||
102 ((m_check->type == MUTT_UNKNOWN) && S_ISREG(st.st_mode) && (st.st_size == 0)) ||
103 ((m_check->type == MUTT_UNKNOWN) &&
104 ((m_check->type = mx_path_probe(mailbox_path(m_check))) <= 0)))
105 {
106 /* if the mailbox still doesn't exist, set the newly created flag to be
107 * ready for when it does. */
108 m_check->newly_created = true;
109 m_check->type = MUTT_UNKNOWN;
110 m_check->size = 0;
111 return;
112 }
113 break; // kept for consistency.
114 }
115
116 const bool c_check_mbox_size = cs_subset_bool(NeoMutt->sub, "check_mbox_size");
117
118 /* check to see if the folder is the currently selected folder before polling */
119 if (!is_same_mailbox(m_cur, m_check, st_ctx, &st))
120 {
121 switch (m_check->type)
122 {
123 case MUTT_NOTMUCH:
124 // Remove this when non-notmuch backends only check unread, flagged,
125 // and total counts per 'mbox_check_stats' docs.
126 if ((flags & MUTT_MAILBOX_CHECK_FORCE_STATS) == 0)
127 break;
128 /* fall through */
129 case MUTT_IMAP:
130 case MUTT_MBOX:
131 case MUTT_MMDF:
132 case MUTT_MAILDIR:
133 case MUTT_MH:
134 mx_mbox_check_stats(m_check, flags);
135 break;
136 default:; /* do nothing */
137 }
138 }
139 else if (c_check_mbox_size && m_cur && buf_is_empty(&m_cur->pathbuf))
140 {
141 m_check->size = (off_t) st.st_size; /* update the size of current folder */
142 }
143
144 if (!m_check->has_new)
145 m_check->notified = false;
146 else if (!m_check->notified)
148}
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:73
MailboxType
Supported mailbox formats.
Definition: mailbox.h:41
@ MUTT_MMDF
'mmdf' Mailbox type
Definition: mailbox.h:46
@ MUTT_MH
'MH' Mailbox type
Definition: mailbox.h:47
@ MUTT_MBOX
'mbox' Mailbox type
Definition: mailbox.h:45
@ MUTT_UNKNOWN
Mailbox wasn't recognised.
Definition: mailbox.h:44
@ MUTT_MAILDIR
'Maildir' Mailbox type
Definition: mailbox.h:48
static short MailboxNotify
Definition: mutt_mailbox.c:45
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:56
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:1817
enum MailboxType mx_path_probe(const char *path)
Find a mailbox that understands a path.
Definition: mx.c:1344
#define MUTT_MAILBOX_CHECK_FORCE_STATS
Ignore MailboxType and calculate statistics.
Definition: mxapi.h:76
bool has_new
Mailbox has new mail.
Definition: mailbox.h:85
bool newly_created
Mbox or mmdf just popped into existence.
Definition: mailbox.h:103
bool notified
User has been notified.
Definition: mailbox.h:101
off_t size
Size of the Mailbox.
Definition: mailbox.h:84
Container for Accounts, Notifications.
Definition: neomutt.h:37
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:39
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_mailbox_check()

int mutt_mailbox_check ( struct Mailbox m_cur,
CheckStatsFlags  flags 
)

Check all all Mailboxes for new mail.

Parameters
m_curCurrent Mailbox
flagsFlags, e.g. MUTT_MAILBOX_CHECK_FORCE
Return values
numNumber of mailboxes with new mail

Check all all Mailboxes for new mail and total/new/flagged messages

Definition at line 158 of file mutt_mailbox.c.

159{
160 struct stat st_ctx = { 0 };
161 time_t t;
162 st_ctx.st_dev = 0;
163 st_ctx.st_ino = 0;
164
165#ifdef USE_IMAP
166 if (flags & MUTT_MAILBOX_CHECK_FORCE)
168#endif
169
170 /* fastest return if there are no mailboxes */
172 return 0;
173
174 const short c_mail_check = cs_subset_number(NeoMutt->sub, "mail_check");
175 const bool c_mail_check_stats = cs_subset_bool(NeoMutt->sub, "mail_check_stats");
176 const short c_mail_check_stats_interval = cs_subset_number(NeoMutt->sub, "mail_check_stats_interval");
177
178 t = mutt_date_now();
179 if ((flags == MUTT_MAILBOX_CHECK_NO_FLAGS) && (t - MailboxTime < c_mail_check))
180 return MailboxCount;
181
182 if ((flags & MUTT_MAILBOX_CHECK_FORCE_STATS) ||
183 (c_mail_check_stats && ((t - MailboxStatsTime) >= c_mail_check_stats_interval)))
184 {
187 }
188
189 MailboxTime = t;
190 MailboxCount = 0;
191 MailboxNotify = 0;
192
193 /* check device ID and serial number instead of comparing paths */
194 if (!m_cur || (m_cur->type == MUTT_IMAP) || (m_cur->type == MUTT_POP)
195#ifdef USE_NNTP
196 || (m_cur->type == MUTT_NNTP)
197#endif
198 || stat(mailbox_path(m_cur), &st_ctx) != 0)
199 {
200 st_ctx.st_dev = 0;
201 st_ctx.st_ino = 0;
202 }
203
204 struct MailboxList ml = STAILQ_HEAD_INITIALIZER(ml);
206 struct MailboxNode *np = NULL;
207 STAILQ_FOREACH(np, &ml, entries)
208 {
209 if (!np->mailbox->visible)
210 continue;
211
212 CheckStatsFlags m_flags = flags;
213 if (!np->mailbox->first_check_stats_done && c_mail_check_stats)
214 {
216 }
217 mailbox_check(m_cur, np->mailbox, &st_ctx, m_flags);
218 if (np->mailbox->has_new)
219 MailboxCount++;
221 }
223
224 return MailboxCount;
225}
short cs_subset_number(const struct ConfigSubset *sub, const char *name)
Get a number config item by name.
Definition: helpers.c:169
@ MUTT_MAILBOX_ANY
Match any Mailbox type.
Definition: mailbox.h:42
time_t mutt_date_now(void)
Return the number of seconds since the Unix epoch.
Definition: date.c:446
static time_t MailboxStatsTime
last time we check performed mail_check_stats
Definition: mutt_mailbox.c:43
static short MailboxCount
how many boxes with new mail
Definition: mutt_mailbox.c:44
static void mailbox_check(struct Mailbox *m_cur, struct Mailbox *m_check, struct stat *st_ctx, CheckStatsFlags flags)
Check a mailbox for new mail.
Definition: mutt_mailbox.c:81
static time_t MailboxTime
last time we started checking for mail
Definition: mutt_mailbox.c:42
#define MUTT_MAILBOX_CHECK_NO_FLAGS
No flags are set.
Definition: mxapi.h:74
#define MUTT_MAILBOX_CHECK_FORCE
Ignore MailboxTime and check for new mail.
Definition: mxapi.h:75
uint8_t CheckStatsFlags
Flags for mutt_mailbox_check.
Definition: mxapi.h:73
void neomutt_mailboxlist_clear(struct MailboxList *ml)
Free a Mailbox List.
Definition: neomutt.c:141
size_t neomutt_mailboxlist_get_all(struct MailboxList *head, struct NeoMutt *n, enum MailboxType type)
Get a List of all Mailboxes.
Definition: neomutt.c:164
void mutt_update_num_postponed(void)
Force the update of the number of postponed messages.
Definition: postpone.c:185
#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
List of Mailboxes.
Definition: mailbox.h:152
struct Mailbox * mailbox
Mailbox in the list.
Definition: mailbox.h:153
bool first_check_stats_done
True when the check have been done at least on time.
Definition: mailbox.h:112
bool visible
True if a result of "mailboxes".
Definition: mailbox.h:130
struct AccountList accounts
List of all Accounts.
Definition: neomutt.h:40
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_mailbox_notify()

bool mutt_mailbox_notify ( struct Mailbox m_cur)

Notify the user if there's new mail.

Parameters
m_curCurrent Mailbox
Return values
trueThere is new mail

Definition at line 232 of file mutt_mailbox.c.

233{
235 {
236 return mutt_mailbox_list();
237 }
238 return false;
239}
int mutt_mailbox_check(struct Mailbox *m_cur, CheckStatsFlags flags)
Check all all Mailboxes for new mail.
Definition: mutt_mailbox.c:158
bool mutt_mailbox_list(void)
List the mailboxes with new mail.
Definition: mutt_mailbox.c:245
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_mailbox_list()

bool mutt_mailbox_list ( void  )

List the mailboxes with new mail.

Return values
trueThere is new mail

Definition at line 245 of file mutt_mailbox.c.

246{
247 char mailboxlist[512] = { 0 };
248 size_t pos = 0;
249 int first = 1;
250
251 int have_unnotified = MailboxNotify;
252
253 struct Buffer *path = buf_pool_get();
254
255 mailboxlist[0] = '\0';
256 pos += strlen(strncat(mailboxlist, _("New mail in "), sizeof(mailboxlist) - 1 - pos));
257 struct MailboxList ml = STAILQ_HEAD_INITIALIZER(ml);
259 struct MailboxNode *np = NULL;
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 const size_t width = msgwin_get_width();
270 if (!first && (width >= 7) && ((pos + buf_len(path)) >= (width - 7)))
271 {
272 break;
273 }
274
275 if (!first)
276 pos += strlen(strncat(mailboxlist + pos, ", ", sizeof(mailboxlist) - 1 - pos));
277
278 /* Prepend an asterisk to mailboxes not already notified */
279 if (!np->mailbox->notified)
280 {
281 np->mailbox->notified = true;
283 }
284 pos += strlen(strncat(mailboxlist + pos, buf_string(path), sizeof(mailboxlist) - 1 - pos));
285 first = 0;
286 }
288
289 if (!first && np)
290 {
291 strncat(mailboxlist + pos, ", ...", sizeof(mailboxlist) - 1 - pos);
292 }
293
294 buf_pool_release(&path);
295
296 if (!first)
297 {
298 mutt_message("%s", mailboxlist);
299 return true;
300 }
301
302 /* there were no mailboxes needing to be notified, so clean up since
303 * MailboxNotify has somehow gotten out of sync */
304 MailboxNotify = 0;
305 return false;
306}
size_t buf_len(const struct Buffer *buf)
Calculate the length of a Buffer.
Definition: buffer.c:414
size_t buf_strcpy(struct Buffer *buf, const char *s)
Copy a string into a Buffer.
Definition: buffer.c:370
static const char * buf_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:78
#define mutt_message(...)
Definition: logging2.h:86
size_t msgwin_get_width(void)
Get the width of the Message Window.
Definition: msgwin.c:270
#define _(a)
Definition: message.h:28
void buf_pretty_mailbox(struct Buffer *buf)
Shorten a mailbox path using '~' or '='.
Definition: muttlib.c:560
struct Buffer * buf_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:106
void buf_pool_release(struct Buffer **ptr)
Return a Buffer to the pool.
Definition: pool.c:119
String manipulation buffer.
Definition: buffer.h:34
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_mailbox_set_notified()

void mutt_mailbox_set_notified ( struct Mailbox m)

Note when the user was last notified of new mail.

Parameters
mMailbox

Definition at line 312 of file mutt_mailbox.c.

313{
314 if (!m)
315 return;
316
317 m->notified = true;
318#ifdef HAVE_CLOCK_GETTIME
319 clock_gettime(CLOCK_REALTIME, &m->last_visited);
320#else
322 m->last_visited.tv_nsec = 0;
323#endif
324}
struct timespec last_visited
Time of last exit from this mailbox.
Definition: mailbox.h:105
long tv_nsec
Number of nanosecond, on top.
Definition: file.h:52
time_t tv_sec
Number of seconds since the epoch.
Definition: file.h:51
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ find_next_mailbox()

static struct Mailbox * find_next_mailbox ( struct Buffer s,
bool  find_new 
)
static

Find the next mailbox with new or unread mail.

Parameters
sBuffer containing name of current mailbox
find_newBoolean controlling new or unread check
Return values
ptrMailbox

Given a folder name, find the next incoming folder with new or unread mail. The Mailbox will be returned and a pretty version of the path put into s.

Definition at line 335 of file mutt_mailbox.c.

336{
337 bool found = false;
338 for (int pass = 0; pass < 2; pass++)
339 {
340 struct MailboxList ml = STAILQ_HEAD_INITIALIZER(ml);
342 struct MailboxNode *np = NULL;
343 STAILQ_FOREACH(np, &ml, entries)
344 {
345 // Match only real mailboxes if looking for new mail.
346 if (find_new && np->mailbox->type == MUTT_NOTMUCH)
347 continue;
348
350 struct Mailbox *m_cur = np->mailbox;
351
352 if ((found || (pass > 0)) && (find_new ? m_cur->has_new : m_cur->msg_unread > 0))
353 {
356 struct Mailbox *m_result = np->mailbox;
358 return m_result;
359 }
361 found = true;
362 }
364 }
365
366 return NULL;
367}
void buf_expand_path(struct Buffer *buf)
Create the canonical path.
Definition: muttlib.c:333
A mailbox.
Definition: mailbox.h:79
int msg_unread
Number of unread messages.
Definition: mailbox.h:89
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_mailbox_next()

struct Mailbox * mutt_mailbox_next ( struct Mailbox m_cur,
struct Buffer s 
)

Incoming folders completion routine.

Parameters
m_curCurrent Mailbox
sBuffer containing name of current mailbox
Return values
ptrMailbox

Given a folder name, find the next incoming folder with new mail. The Mailbox will be returned and a pretty version of the path put into s.

Definition at line 378 of file mutt_mailbox.c.

379{
381
383 {
384 struct Mailbox *m_res = find_next_mailbox(s, true);
385 if (m_res)
386 return m_res;
387
388 mutt_mailbox_check(m_cur, MUTT_MAILBOX_CHECK_FORCE); /* mailbox was wrong - resync things */
389 }
390
391 buf_reset(s); // no folders with new mail
392 return NULL;
393}
void buf_reset(struct Buffer *buf)
Reset an existing Buffer.
Definition: buffer.c:86
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:335
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_mailbox_next_unread()

struct Mailbox * mutt_mailbox_next_unread ( struct Mailbox m_cur,
struct Buffer s 
)

Find next mailbox with unread mail.

Parameters
m_curCurrent Mailbox
sBuffer containing name of current mailbox
Return values
ptrMailbox

Given a folder name, find the next mailbox with unread mail. The Mailbox will be returned and a pretty version of the path put into s.

Definition at line 404 of file mutt_mailbox.c.

405{
407
408 struct Mailbox *m_res = find_next_mailbox(s, false);
409 if (m_res)
410 return m_res;
411
412 buf_reset(s); // no folders with new mail
413 return NULL;
414}
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_mailbox_cleanup()

void mutt_mailbox_cleanup ( const char *  path,
struct stat *  st 
)

Restore the timestamp of a mailbox.

Parameters
pathPath to the mailbox
stTimestamp info from stat()

Fix up the atime and mtime after mbox/mmdf mailbox was modified according to stat() info taken before a modification.

Definition at line 424 of file mutt_mailbox.c.

425{
426#ifdef HAVE_UTIMENSAT
427 struct timespec ts[2];
428#else
429 struct utimbuf ut;
430#endif
431
432 const bool c_check_mbox_size = cs_subset_bool(NeoMutt->sub, "check_mbox_size");
433 if (c_check_mbox_size)
434 {
435 struct Mailbox *m = mailbox_find(path);
436 if (m && !m->has_new)
438 }
439 else
440 {
441 /* fix up the times so mailbox won't get confused */
442 if (st->st_mtime > st->st_atime)
443 {
444#ifdef HAVE_UTIMENSAT
445 ts[0].tv_sec = 0;
446 ts[0].tv_nsec = UTIME_OMIT;
447 ts[1].tv_sec = 0;
448 ts[1].tv_nsec = UTIME_NOW;
449 utimensat(AT_FDCWD, buf, ts, 0);
450#else
451 ut.actime = st->st_atime;
452 ut.modtime = mutt_date_now();
453 utime(path, &ut);
454#endif
455 }
456 else
457 {
458#ifdef HAVE_UTIMENSAT
459 ts[0].tv_sec = 0;
460 ts[0].tv_nsec = UTIME_NOW;
461 ts[1].tv_sec = 0;
462 ts[1].tv_nsec = UTIME_NOW;
463 utimensat(AT_FDCWD, buf, ts, 0);
464#else
465 utime(path, NULL);
466#endif
467 }
468 }
469}
void mailbox_update(struct Mailbox *m)
Get the mailbox's current size.
Definition: mailbox.c:205
struct Mailbox * mailbox_find(const char *path)
Find the mailbox with a given path.
Definition: mailbox.c:140
Time value with nanosecond precision.
Definition: file.h:50
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

Variable Documentation

◆ MailboxTime

time_t MailboxTime = 0
static

last time we started checking for mail

Definition at line 42 of file mutt_mailbox.c.

◆ MailboxStatsTime

time_t MailboxStatsTime = 0
static

last time we check performed mail_check_stats

Definition at line 43 of file mutt_mailbox.c.

◆ MailboxCount

short MailboxCount = 0
static

how many boxes with new mail

Definition at line 44 of file mutt_mailbox.c.

◆ MailboxNotify

short MailboxNotify = 0
static

of unnotified new boxes

Definition at line 45 of file mutt_mailbox.c.