mutt_mailbox.h File Reference

#include <stdbool.h>

Include dependency graph for mutt_mailbox.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	MUTT_MAILBOX_CHECK_FORCE   (1 << 0)
#define	MUTT_MAILBOX_CHECK_FORCE_STATS   (1 << 1)

Functions
int	mutt_mailbox_check (struct Mailbox *m_cur, int force)
	Check all all Mailboxes for new mail. More...
void	mutt_mailbox_cleanup (const char *path, struct stat *st)
	Restore the timestamp of a mailbox. More...
bool	mutt_mailbox_list (void)
	List the mailboxes with new mail. More...
struct Mailbox *	mutt_mailbox_next (struct Mailbox *m_cur, struct Buffer *s)
	incoming folders completion routine More...
bool	mutt_mailbox_notify (struct Mailbox *m_cur)
	Notify the user if there's new mail. More...
void	mutt_mailbox_set_notified (struct Mailbox *m)
	Note when the user was last notified of new mail. More...

Variables
short	C_MailCheck
	Config: Number of seconds before NeoMutt checks for new mail. More...
bool	C_MailCheckStats
	Config: Periodically check for new mail. More...
short	C_MailCheckStatsInterval
	Config: How often to check for new mail. More...

Macro Definition Documentation

MUTT_MAILBOX_CHECK_FORCE

#define MUTT_MAILBOX_CHECK_FORCE   (1 << 0)

Definition at line 16 of file mutt_mailbox.h.

MUTT_MAILBOX_CHECK_FORCE_STATS

#define MUTT_MAILBOX_CHECK_FORCE_STATS   (1 << 1)

Definition at line 17 of file mutt_mailbox.h.

Function Documentation

mutt_mailbox_check()

int mutt_mailbox_check	(	struct Mailbox *	m_cur,
		int	force
	)

Check all all Mailboxes for new mail.

Parameters

m_cur	Current Mailbox
force	Force flags, see below

Return values

num	Number 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 153 of file mutt_mailbox.c.

{
  struct stat contex_sb;
  time_t t;
  bool check_stats = false;
  contex_sb.st_dev = 0;
  contex_sb.st_ino = 0;

#ifdef USE_IMAP
  /* update postponed count as well, on force */
  if (force & MUTT_MAILBOX_CHECK_FORCE)
    mutt_update_num_postponed();
#endif

  /* fastest return if there are no mailboxes */
  if (TAILQ_EMPTY(&NeoMutt->accounts))
    return 0;

  t = mutt_date_epoch();
  if (!force && (t - MailboxTime < C_MailCheck))
    return MailboxCount;

  if ((force & MUTT_MAILBOX_CHECK_FORCE_STATS) ||
      (C_MailCheckStats && ((t - MailboxStatsTime) >= C_MailCheckStatsInterval)))
  {
    check_stats = true;
    MailboxStatsTime = t;
  }

  MailboxTime = t;
  MailboxCount = 0;
  MailboxNotify = 0;

  /* check device ID and serial number instead of comparing paths */
  if (!m_cur || (m_cur->type == MUTT_IMAP) || (m_cur->type == MUTT_POP)
#ifdef USE_NNTP
      || (m_cur->type == MUTT_NNTP)
#endif
      || stat(mailbox_path(m_cur), &contex_sb) != 0)
  {
    contex_sb.st_dev = 0;
    contex_sb.st_ino = 0;
  }

  struct MailboxList ml = STAILQ_HEAD_INITIALIZER(ml);
  neomutt_mailboxlist_get_all(&ml, NeoMutt, MUTT_MAILBOX_ANY);
  struct MailboxNode *np = NULL;
  STAILQ_FOREACH(np, &ml, entries)
  {
    if (np->mailbox->flags & MB_HIDDEN)
      continue;

    mailbox_check(m_cur, np->mailbox, &contex_sb,
                  check_stats || (!np->mailbox->first_check_stats_done && C_MailCheckStats));
    np->mailbox->first_check_stats_done = true;
  }
  neomutt_mailboxlist_clear(&ml);

  return MailboxCount;
}

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

path	Path to the mailbox
st	Timestamp 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 369 of file mutt_mailbox.c.

{
#ifdef HAVE_UTIMENSAT
  struct timespec ts[2];
#else
  struct utimbuf ut;
#endif

  if (C_CheckMboxSize)
  {
    struct Mailbox *m = mailbox_find(path);
    if (m && !m->has_new)
      mailbox_update(m);
  }
  else
  {
    /* fix up the times so mailbox won't get confused */
    if (st->st_mtime > st->st_atime)
    {
#ifdef HAVE_UTIMENSAT
      ts[0].tv_sec = 0;
      ts[0].tv_nsec = UTIME_OMIT;
      ts[1].tv_sec = 0;
      ts[1].tv_nsec = UTIME_NOW;
      utimensat(AT_FDCWD, buf, ts, 0);
#else
      ut.actime = st->st_atime;
      ut.modtime = mutt_date_epoch();
      utime(path, &ut);
#endif
    }
    else
    {
#ifdef HAVE_UTIMENSAT
      ts[0].tv_sec = 0;
      ts[0].tv_nsec = UTIME_NOW;
      ts[1].tv_sec = 0;
      ts[1].tv_nsec = UTIME_NOW;
      utimensat(AT_FDCWD, buf, ts, 0);
#else
      utime(path, NULL);
#endif
    }
  }
}

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

true	If there is new mail

Definition at line 232 of file mutt_mailbox.c.

{
  char mailboxlist[512];
  size_t pos = 0;
  int first = 1;

  int have_unnotified = MailboxNotify;

  struct Buffer *path = mutt_buffer_pool_get();

  mailboxlist[0] = '\0';
  pos += strlen(strncat(mailboxlist, _("New mail in "), sizeof(mailboxlist) - 1 - pos));
  struct MailboxList ml = STAILQ_HEAD_INITIALIZER(ml);
  neomutt_mailboxlist_get_all(&ml, NeoMutt, MUTT_MAILBOX_ANY);
  struct MailboxNode *np = NULL;
  STAILQ_FOREACH(np, &ml, entries)
  {
    /* Is there new mail in this mailbox? */
    if (!np->mailbox->has_new || (have_unnotified && np->mailbox->notified))
      continue;

    mutt_buffer_strcpy(path, mailbox_path(np->mailbox));
    mutt_buffer_pretty_mailbox(path);

    if (!first && (MessageWindow->state.cols >= 7) &&
        ((pos + mutt_buffer_len(path)) >= ((size_t) MessageWindow->state.cols - 7)))
    {
      break;
    }

    if (!first)
      pos += strlen(strncat(mailboxlist + pos, ", ", sizeof(mailboxlist) - 1 - pos));

    /* Prepend an asterisk to mailboxes not already notified */
    if (!np->mailbox->notified)
    {
      /* pos += strlen (strncat(mailboxlist + pos, "*", sizeof(mailboxlist)-1-pos)); */
      np->mailbox->notified = true;
      MailboxNotify--;
    }
    pos += strlen(strncat(mailboxlist + pos, mutt_b2s(path), sizeof(mailboxlist) - 1 - pos));
    first = 0;
  }
  neomutt_mailboxlist_clear(&ml);

  if (!first && np)
  {
    strncat(mailboxlist + pos, ", ...", sizeof(mailboxlist) - 1 - pos);
  }

  mutt_buffer_pool_release(&path);

  if (!first)
  {
    mutt_message("%s", mailboxlist);
    return true;
  }

  /* there were no mailboxes needing to be notified, so clean up since
    * MailboxNotify has somehow gotten out of sync */
  MailboxNotify = 0;
  return false;
}

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_cur	Current Mailbox
s	Buffer containing name of current mailbox

Return values

ptr

Mailbox

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 323 of file mutt_mailbox.c.

{
  mutt_buffer_expand_path(s);

  if (mutt_mailbox_check(m_cur, 0) > 0)
  {
    bool found = false;
    for (int pass = 0; pass < 2; pass++)
    {
      struct MailboxList ml = STAILQ_HEAD_INITIALIZER(ml);
      neomutt_mailboxlist_get_all(&ml, NeoMutt, MUTT_MAILBOX_ANY);
      struct MailboxNode *np = NULL;
      STAILQ_FOREACH(np, &ml, entries)
      {
        if (np->mailbox->type == MUTT_NOTMUCH) /* only match real mailboxes */
          continue;
        mutt_buffer_expand_path(&np->mailbox->pathbuf);
        if ((found || (pass > 0)) && np->mailbox->has_new)
        {
          mutt_buffer_strcpy(s, mailbox_path(np->mailbox));
          mutt_buffer_pretty_mailbox(s);
          struct Mailbox *m_result = np->mailbox;
          neomutt_mailboxlist_clear(&ml);
          return m_result;
        }
        if (mutt_str_equal(mutt_b2s(s), mailbox_path(np->mailbox)))
          found = true;
      }
      neomutt_mailboxlist_clear(&ml);
    }

    mutt_mailbox_check(m_cur, MUTT_MAILBOX_CHECK_FORCE); /* mailbox was wrong - resync things */
  }

  mutt_buffer_reset(s); // no folders with new mail
  return NULL;
}

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_cur

Current Mailbox

Return values

true	If there is new mail

Definition at line 219 of file mutt_mailbox.c.

{
  if ((mutt_mailbox_check(m_cur, 0) > 0) && MailboxNotify)
  {
    return mutt_mailbox_list();
  }
  return false;
}

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

m

Mailbox

Definition at line 300 of file mutt_mailbox.c.

{
  if (!m)
    return;

  m->notified = true;
#ifdef HAVE_CLOCK_GETTIME
  clock_gettime(CLOCK_REALTIME, &m->last_visited);
#else
  m->last_visited.tv_sec = mutt_date_epoch();
  m->last_visited.tv_nsec = 0;
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

C_MailCheck

short C_MailCheck

Config: Number of seconds before NeoMutt checks for new mail.

Definition at line 51 of file mutt_mailbox.c.

C_MailCheckStats

bool C_MailCheckStats

Config: Periodically check for new mail.

Definition at line 52 of file mutt_mailbox.c.

C_MailCheckStatsInterval

short C_MailCheckStatsInterval

Config: How often to check for new mail.

Definition at line 53 of file mutt_mailbox.c.