NeoMutt  2021-10-22-8-g9cb437
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 "muttlib.h"
#include "mx.h"
#include "protos.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, bool check_stats)
 Check a mailbox for new mail. More...
 
int mutt_mailbox_check (struct Mailbox *m_cur, int force)
 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 || mutt_buffer_is_empty(&m1->pathbuf) || !m2 ||
60  mutt_buffer_is_empty(&m2->pathbuf) || (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)
69  return mutt_str_equal(mailbox_path(m1), mailbox_path(m2));
70  else
71  return ((st1->st_dev == st2->st_dev) && (st1->st_ino == st2->st_ino));
72 }
bool mutt_buffer_is_empty(const struct Buffer *buf)
Is the Buffer empty?
Definition: buffer.c:252
static const char * mailbox_path(const struct Mailbox *m)
Get the Mailbox's path string.
Definition: mailbox.h:215
@ MUTT_NOTMUCH
'Notmuch' (virtual) Mailbox type
Definition: mailbox.h:54
@ MUTT_POP
'POP3' Mailbox type
Definition: mailbox.h:55
@ MUTT_NNTP
'NNTP' (Usenet) Mailbox type
Definition: mailbox.h:52
@ MUTT_IMAP
'IMAP' Mailbox type
Definition: mailbox.h:53
bool mutt_str_equal(const char *a, const char *b)
Compare two strings.
Definition: string.c:904
enum MailboxType type
Mailbox type.
Definition: mailbox.h:105
struct Buffer pathbuf
Path of the Mailbox.
Definition: mailbox.h:83
+ 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,
bool  check_stats 
)
static

Check a mailbox for new mail.

Parameters
m_curCurrent Mailbox
m_checkMailbox to check
st_ctxstat() info for the current Mailbox
check_statsIf true, also count the total, new and flagged messages

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 =
89  cs_subset_bool(NeoMutt->sub, "mail_check_recent");
90  if ((m_cur == m_check) && c_mail_check_recent)
91  m_check->has_new = false;
92 
93  switch (mb_type)
94  {
95  case MUTT_POP:
96  case MUTT_NNTP:
97  case MUTT_NOTMUCH:
98  case MUTT_IMAP:
99  m_check->type = mb_type;
100  break;
101  default:
102  if ((stat(mailbox_path(m_check), &st) != 0) ||
103  ((m_check->type == MUTT_UNKNOWN) && S_ISREG(st.st_mode) && (st.st_size == 0)) ||
104  ((m_check->type == MUTT_UNKNOWN) &&
105  ((m_check->type = mx_path_probe(mailbox_path(m_check))) <= 0)))
106  {
107  /* if the mailbox still doesn't exist, set the newly created flag to be
108  * ready for when it does. */
109  m_check->newly_created = true;
110  m_check->type = MUTT_UNKNOWN;
111  m_check->size = 0;
112  return;
113  }
114  break; // kept for consistency.
115  }
116 
117  const bool c_check_mbox_size =
118  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_ctx, &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 (!check_stats)
129  break;
130  /* fall through */
131  case MUTT_IMAP:
132  case MUTT_MBOX:
133  case MUTT_MMDF:
134  case MUTT_MAILDIR:
135  case MUTT_MH:
136  mx_mbox_check_stats(m_check, check_stats);
137  break;
138  default:; /* do nothing */
139  }
140  }
141  else if (c_check_mbox_size && m_cur && mutt_buffer_is_empty(&m_cur->pathbuf))
142  m_check->size = (off_t) st.st_size; /* update the size of current folder */
143 
144  if (!m_check->has_new)
145  m_check->notified = false;
146  else if (!m_check->notified)
147  MailboxNotify++;
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:44
@ MUTT_MMDF
'mmdf' Mailbox type
Definition: mailbox.h:49
@ MUTT_MH
'MH' Mailbox type
Definition: mailbox.h:50
@ MUTT_MBOX
'mbox' Mailbox type
Definition: mailbox.h:48
@ MUTT_UNKNOWN
Mailbox wasn't recognised.
Definition: mailbox.h:47
@ MUTT_MAILDIR
'Maildir' Mailbox type
Definition: mailbox.h:51
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:1794
enum MailboxType mx_path_probe(const char *path)
Find a mailbox that understands a path.
Definition: mx.c:1320
bool has_new
Mailbox has new mail.
Definition: mailbox.h:88
bool newly_created
Mbox or mmdf just popped into existence.
Definition: mailbox.h:106
bool notified
User has been notified.
Definition: mailbox.h:104
off_t size
Size of the Mailbox.
Definition: mailbox.h:87
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,
int  force 
)

Check all all Mailboxes for new mail.

Parameters
m_curCurrent Mailbox
forceForce flags, see below
Return values
numNumber of mailboxes with new mail

The force argument may be any combination of the following values:

  • MUTT_MAILBOX_CHECK_FORCE ignore MailboxTime and check for new mail
  • MUTT_MAILBOX_CHECK_FORCE_STATS ignore MailboxTime and calculate statistics

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

Definition at line 162 of file mutt_mailbox.c.

163 {
164  struct stat st_ctx = { 0 };
165  time_t t;
166  bool check_stats = false;
167  st_ctx.st_dev = 0;
168  st_ctx.st_ino = 0;
169 
170 #ifdef USE_IMAP
171  /* update postponed count as well, on force */
172  if (force & MUTT_MAILBOX_CHECK_FORCE)
174 #endif
175 
176  /* fastest return if there are no mailboxes */
178  return 0;
179 
180  const short c_mail_check = cs_subset_number(NeoMutt->sub, "mail_check");
181  const bool c_mail_check_stats =
182  cs_subset_bool(NeoMutt->sub, "mail_check_stats");
183  const short c_mail_check_stats_interval =
184  cs_subset_number(NeoMutt->sub, "mail_check_stats_interval");
185 
186  t = mutt_date_epoch();
187  if (!force && (t - MailboxTime < c_mail_check))
188  return MailboxCount;
189 
190  if ((force & MUTT_MAILBOX_CHECK_FORCE_STATS) ||
191  (c_mail_check_stats && ((t - MailboxStatsTime) >= c_mail_check_stats_interval)))
192  {
193  check_stats = true;
194  MailboxStatsTime = t;
195  }
196 
197  MailboxTime = t;
198  MailboxCount = 0;
199  MailboxNotify = 0;
200 
201  /* check device ID and serial number instead of comparing paths */
202  if (!m_cur || (m_cur->type == MUTT_IMAP) || (m_cur->type == MUTT_POP)
203 #ifdef USE_NNTP
204  || (m_cur->type == MUTT_NNTP)
205 #endif
206  || stat(mailbox_path(m_cur), &st_ctx) != 0)
207  {
208  st_ctx.st_dev = 0;
209  st_ctx.st_ino = 0;
210  }
211 
212  struct MailboxList ml = STAILQ_HEAD_INITIALIZER(ml);
214  struct MailboxNode *np = NULL;
215  STAILQ_FOREACH(np, &ml, entries)
216  {
217  if (np->mailbox->flags & MB_HIDDEN)
218  continue;
219 
220  mailbox_check(m_cur, np->mailbox, &st_ctx,
221  check_stats || (!np->mailbox->first_check_stats_done && c_mail_check_stats));
222  if (np->mailbox->has_new)
223  MailboxCount++;
224  np->mailbox->first_check_stats_done = true;
225  }
227 
228  return MailboxCount;
229 }
time_t mutt_date_epoch(void)
Return the number of seconds since the Unix epoch.
Definition: date.c:427
short cs_subset_number(const struct ConfigSubset *sub, const char *name)
Get a number config item by name.
Definition: helpers.c:169
#define MB_HIDDEN
Definition: mailbox.h:38
@ MUTT_MAILBOX_ANY
Match any Mailbox type.
Definition: mailbox.h:45
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, bool check_stats)
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_FORCE_STATS
Definition: mutt_mailbox.h:33
#define MUTT_MAILBOX_CHECK_FORCE
Definition: mutt_mailbox.h:32
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:184
#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:157
struct Mailbox * mailbox
Mailbox in the list.
Definition: mailbox.h:158
bool first_check_stats_done
True when the check have been done at least on time.
Definition: mailbox.h:116
uint8_t flags
e.g. MB_NORMAL
Definition: mailbox.h:134
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 236 of file mutt_mailbox.c.

237 {
238  if ((mutt_mailbox_check(m_cur, 0) > 0) && MailboxNotify)
239  {
240  return mutt_mailbox_list();
241  }
242  return false;
243 }
int mutt_mailbox_check(struct Mailbox *m_cur, int force)
Check all all Mailboxes for new mail.
Definition: mutt_mailbox.c:162
bool mutt_mailbox_list(void)
List the mailboxes with new mail.
Definition: mutt_mailbox.c:249
+ 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 249 of file mutt_mailbox.c.

250 {
251  char mailboxlist[512];
252  size_t pos = 0;
253  int first = 1;
254 
255  int have_unnotified = MailboxNotify;
256 
257  struct Buffer *path = mutt_buffer_pool_get();
258 
259  mailboxlist[0] = '\0';
260  pos += strlen(strncat(mailboxlist, _("New mail in "), sizeof(mailboxlist) - 1 - pos));
261  struct MailboxList ml = STAILQ_HEAD_INITIALIZER(ml);
263  struct MailboxNode *np = NULL;
264  STAILQ_FOREACH(np, &ml, entries)
265  {
266  /* Is there new mail in this mailbox? */
267  if (!np->mailbox->has_new || (have_unnotified && np->mailbox->notified))
268  continue;
269 
272 
273  const size_t width = msgwin_get_width();
274  if (!first && (width >= 7) && ((pos + mutt_buffer_len(path)) >= (width - 7)))
275  {
276  break;
277  }
278 
279  if (!first)
280  pos += strlen(strncat(mailboxlist + pos, ", ", sizeof(mailboxlist) - 1 - pos));
281 
282  /* Prepend an asterisk to mailboxes not already notified */
283  if (!np->mailbox->notified)
284  {
285  /* pos += strlen (strncat(mailboxlist + pos, "*", sizeof(mailboxlist)-1-pos)); */
286  np->mailbox->notified = true;
287  MailboxNotify--;
288  }
289  pos += strlen(strncat(mailboxlist + pos, mutt_buffer_string(path),
290  sizeof(mailboxlist) - 1 - pos));
291  first = 0;
292  }
294 
295  if (!first && np)
296  {
297  strncat(mailboxlist + pos, ", ...", sizeof(mailboxlist) - 1 - pos);
298  }
299 
301 
302  if (!first)
303  {
304  mutt_message("%s", mailboxlist);
305  return true;
306  }
307 
308  /* there were no mailboxes needing to be notified, so clean up since
309  * MailboxNotify has somehow gotten out of sync */
310  MailboxNotify = 0;
311  return false;
312 }
size_t mutt_buffer_strcpy(struct Buffer *buf, const char *s)
Copy a string into a Buffer.
Definition: buffer.c:312
size_t mutt_buffer_len(const struct Buffer *buf)
Calculate the length of a Buffer.
Definition: buffer.c:356
static const char * mutt_buffer_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:77
#define mutt_message(...)
Definition: logging.h:86
size_t msgwin_get_width(void)
Get the width of the Message Window.
Definition: msgwin.c:260
#define _(a)
Definition: message.h:28
void mutt_buffer_pretty_mailbox(struct Buffer *buf)
Shorten a mailbox path using '~' or '='.
Definition: muttlib.c:603
void mutt_buffer_pool_release(struct Buffer **pbuf)
Free a Buffer from the pool.
Definition: pool.c:112
struct Buffer * mutt_buffer_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:101
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 318 of file mutt_mailbox.c.

319 {
320  if (!m)
321  return;
322 
323  m->notified = true;
324 #ifdef HAVE_CLOCK_GETTIME
325  clock_gettime(CLOCK_REALTIME, &m->last_visited);
326 #else
328  m->last_visited.tv_nsec = 0;
329 #endif
330 }
struct timespec last_visited
Time of last exit from this mailbox.
Definition: mailbox.h:108
long tv_nsec
Number of nanosecond, on top.
Definition: file.h:51
time_t tv_sec
Number of seconds since the epoch.
Definition: file.h:50
+ 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 341 of file mutt_mailbox.c.

342 {
343  bool found = false;
344  for (int pass = 0; pass < 2; pass++)
345  {
346  struct MailboxList ml = STAILQ_HEAD_INITIALIZER(ml);
348  struct MailboxNode *np = NULL;
349  STAILQ_FOREACH(np, &ml, entries)
350  {
351  // Match only real mailboxes if looking for new mail.
352  if (find_new && np->mailbox->type == MUTT_NOTMUCH)
353  continue;
354 
356  struct Mailbox *m_cur = np->mailbox;
357 
358  if ((found || (pass > 0)) && (find_new ? m_cur->has_new : m_cur->msg_unread > 0))
359  {
362  struct Mailbox *m_result = np->mailbox;
364  return m_result;
365  }
367  found = true;
368  }
370  }
371 
372  return NULL;
373 }
void mutt_buffer_expand_path(struct Buffer *buf)
Create the canonical path.
Definition: muttlib.c:322
A mailbox.
Definition: mailbox.h:82
int msg_unread
Number of unread messages.
Definition: mailbox.h:92
+ 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 384 of file mutt_mailbox.c.

385 {
387 
388  if (mutt_mailbox_check(m_cur, 0) > 0)
389  {
390  struct Mailbox *m_res = find_next_mailbox(s, true);
391  if (m_res)
392  return m_res;
393 
394  mutt_mailbox_check(m_cur, MUTT_MAILBOX_CHECK_FORCE); /* mailbox was wrong - resync things */
395  }
396 
397  mutt_buffer_reset(s); // no folders with new mail
398  return NULL;
399 }
void mutt_buffer_reset(struct Buffer *buf)
Reset an existing Buffer.
Definition: buffer.c:79
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:341
+ 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 410 of file mutt_mailbox.c.

411 {
413 
414  struct Mailbox *m_res = find_next_mailbox(s, false);
415  if (m_res)
416  return m_res;
417 
418  mutt_buffer_reset(s); // no folders with new mail
419  return NULL;
420 }
+ 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 430 of file mutt_mailbox.c.

431 {
432 #ifdef HAVE_UTIMENSAT
433  struct timespec ts[2];
434 #else
435  struct utimbuf ut;
436 #endif
437 
438  const bool c_check_mbox_size =
439  cs_subset_bool(NeoMutt->sub, "check_mbox_size");
440  if (c_check_mbox_size)
441  {
442  struct Mailbox *m = mailbox_find(path);
443  if (m && !m->has_new)
444  mailbox_update(m);
445  }
446  else
447  {
448  /* fix up the times so mailbox won't get confused */
449  if (st->st_mtime > st->st_atime)
450  {
451 #ifdef HAVE_UTIMENSAT
452  ts[0].tv_sec = 0;
453  ts[0].tv_nsec = UTIME_OMIT;
454  ts[1].tv_sec = 0;
455  ts[1].tv_nsec = UTIME_NOW;
456  utimensat(AT_FDCWD, buf, ts, 0);
457 #else
458  ut.actime = st->st_atime;
459  ut.modtime = mutt_date_epoch();
460  utime(path, &ut);
461 #endif
462  }
463  else
464  {
465 #ifdef HAVE_UTIMENSAT
466  ts[0].tv_sec = 0;
467  ts[0].tv_nsec = UTIME_NOW;
468  ts[1].tv_sec = 0;
469  ts[1].tv_nsec = UTIME_NOW;
470  utimensat(AT_FDCWD, buf, ts, 0);
471 #else
472  utime(path, NULL);
473 #endif
474  }
475  }
476 }
void mailbox_update(struct Mailbox *m)
Get the mailbox's current size.
Definition: mailbox.c:193
struct Mailbox * mailbox_find(const char *path)
Find the mailbox with a given path.
Definition: mailbox.c:128
Time value with nanosecond precision.
Definition: file.h:49
+ 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.