mbox_check_stats()

Check the Mailbox statistics. More...

Collaboration diagram for mbox_check_stats():

Functions
static enum MxStatus	imap_mbox_check_stats (struct Mailbox *m, uint8_t flags)
	Check the Mailbox statistics - Implements MxOps::mbox_check_stats() -.
enum MxStatus	maildir_mbox_check_stats (struct Mailbox *m, uint8_t flags)
	Check the Mailbox statistics - Implements MxOps::mbox_check_stats() -.
static enum MxStatus	mbox_mbox_check_stats (struct Mailbox *m, uint8_t flags)
	Check the Mailbox statistics - Implements MxOps::mbox_check_stats() -.
static enum MxStatus	mh_mbox_check_stats (struct Mailbox *m, uint8_t flags)
	Check the Mailbox statistics - Implements MxOps::mbox_check_stats() -.
static enum MxStatus	nm_mbox_check_stats (struct Mailbox *m, uint8_t flags)
	Check the Mailbox statistics - Implements MxOps::mbox_check_stats() -.

Detailed Description

Check the Mailbox statistics.

Parameters

m	Mailbox to check
flags	Function flags

Return values

enum

MxStatus

Precondition

m is not NULL

Function Documentation

imap_mbox_check_stats()

static enum MxStatus imap_mbox_check_stats ( struct Mailbox * m, uint8_t flags )

static

Check the Mailbox statistics - Implements MxOps::mbox_check_stats() -.

Definition at line 1345 of file imap.c.

{
  const bool queue = (flags & MUTT_MAILBOX_CHECK_IMMEDIATE) == 0;
  const int new_msgs = imap_mailbox_status(m, queue);
  if (new_msgs == -1)
    return MX_STATUS_ERROR;
  if (new_msgs == 0)
    return MX_STATUS_OK;
  return MX_STATUS_NEW_MAIL;
}

Here is the call graph for this function:

maildir_mbox_check_stats()

enum MxStatus maildir_mbox_check_stats	(	struct Mailbox *	m,
		uint8_t	flags )

Check the Mailbox statistics - Implements MxOps::mbox_check_stats() -.

Definition at line 820 of file mailbox.c.

{
  bool check_stats = flags & MUTT_MAILBOX_CHECK_STATS;
  bool check_new = true;
 
  if (check_stats)
  {
    m->msg_new = 0;
    m->msg_count = 0;
    m->msg_unread = 0;
    m->msg_flagged = 0;
  }
 
  maildir_check_dir(m, "new", check_new, check_stats);
 
  const bool c_maildir_check_cur = cs_subset_bool(NeoMutt->sub, "maildir_check_cur");
  check_new = !m->has_new && c_maildir_check_cur;
  if (check_new || check_stats)
    maildir_check_dir(m, "cur", check_new, check_stats);
 
  return m->msg_new ? MX_STATUS_NEW_MAIL : MX_STATUS_OK;
}

Here is the call graph for this function:

mbox_mbox_check_stats()

static enum MxStatus mbox_mbox_check_stats ( struct Mailbox * m, uint8_t flags )

static

Check the Mailbox statistics - Implements MxOps::mbox_check_stats() -.

Definition at line 1677 of file mbox.c.

{
  struct stat st = { 0 };
  if (stat(mailbox_path(m), &st) != 0)
    return MX_STATUS_ERROR;
 
  bool new_or_changed;
 
  const bool c_check_mbox_size = cs_subset_bool(NeoMutt->sub, "check_mbox_size");
  if (c_check_mbox_size)
  {
    new_or_changed = (st.st_size > m->size);
  }
  else
  {
    new_or_changed =
        (mutt_file_stat_compare(&st, MUTT_STAT_MTIME, &st, MUTT_STAT_ATIME) > 0) ||
        (m->newly_created &&
         (mutt_file_stat_compare(&st, MUTT_STAT_CTIME, &st, MUTT_STAT_MTIME) == 0) &&
         (mutt_file_stat_compare(&st, MUTT_STAT_CTIME, &st, MUTT_STAT_ATIME) == 0));
  }
 
  if (new_or_changed)
  {
    const bool c_mail_check_recent = cs_subset_bool(NeoMutt->sub, "mail_check_recent");
    if (!c_mail_check_recent ||
        (mutt_file_stat_timespec_compare(&st, MUTT_STAT_MTIME, &m->last_visited) > 0))
    {
      m->has_new = true;
    }
  }
  else if (c_check_mbox_size)
  {
    /* some other program has deleted mail from the folder */
    m->size = (off_t) st.st_size;
  }
 
  if (m->newly_created && ((st.st_ctime != st.st_mtime) || (st.st_ctime != st.st_atime)))
    m->newly_created = false;
 
  if (flags & MUTT_MAILBOX_CHECK_STATS)
  {
    struct MboxAccountData *adata = mbox_adata_get(m);
    if (adata && mutt_file_stat_timespec_compare(&st, MUTT_STAT_MTIME,
                                                 &adata->stats_last_checked) > 0)
    {
      bool old_peek = m->peekonly;
      mx_mbox_open(m, MUTT_QUIET | MUTT_NOSORT | MUTT_PEEK);
      mx_mbox_close(m);
      m->peekonly = old_peek;
      mutt_time_now(&adata->stats_last_checked);
    }
  }
 
  if (m->has_new || m->msg_new)
    return MX_STATUS_NEW_MAIL;
  return MX_STATUS_OK;
}

Here is the call graph for this function:

mh_mbox_check_stats()

static enum MxStatus mh_mbox_check_stats ( struct Mailbox * m, uint8_t flags )

static

Check the Mailbox statistics - Implements MxOps::mbox_check_stats() -.

Definition at line 140 of file mh.c.

{
  struct MhSequences mhs = { 0 };
  DIR *dir = NULL;
  struct dirent *de = NULL;
 
  /* when $mail_check_recent is set and the .mh_sequences file hasn't changed
   * since the last m visit, there is no "new mail" */
  const bool c_mail_check_recent = cs_subset_bool(NeoMutt->sub, "mail_check_recent");
  if (c_mail_check_recent && (mh_seq_changed(m) <= 0))
  {
    return MX_STATUS_OK;
  }
 
  if (mh_seq_read(&mhs, mailbox_path(m)) < 0)
    return MX_STATUS_ERROR;
 
  m->msg_count = 0;
  m->msg_unread = 0;
  m->msg_flagged = 0;
 
  enum MxStatus rc = MX_STATUS_OK;
  bool check_new = true;
  for (int i = mhs.max; i > 0; i--)
  {
    if ((mh_seq_check(&mhs, i) & MH_SEQ_FLAGGED))
      m->msg_flagged++;
    if (mh_seq_check(&mhs, i) & MH_SEQ_UNSEEN)
    {
      m->msg_unread++;
      if (check_new)
      {
        /* if the first unseen message we encounter was in the m during the
         * last visit, don't notify about it */
        if (!c_mail_check_recent || (mh_already_notified(m, i) == 0))
        {
          m->has_new = true;
          rc = MX_STATUS_NEW_MAIL;
        }
        /* Because we are traversing from high to low, we can stop
         * checking for new mail after the first unseen message.
         * Whether it resulted in "new mail" or not. */
        check_new = false;
      }
    }
  }
 
  mh_seq_free(&mhs);
 
  dir = mutt_file_opendir(mailbox_path(m), MUTT_OPENDIR_NONE);
  if (dir)
  {
    while ((de = readdir(dir)))
    {
      if (*de->d_name == '.')
        continue;
      if (mh_valid_message(de->d_name))
        m->msg_count++;
    }
    closedir(dir);
  }
 
  return rc;
}

Here is the call graph for this function:

nm_mbox_check_stats()

static enum MxStatus nm_mbox_check_stats ( struct Mailbox * m, uint8_t flags )

static

Check the Mailbox statistics - Implements MxOps::mbox_check_stats() -.

Definition at line 1836 of file notmuch.c.

{
  struct UrlQuery *item = NULL;
  struct Url *url = NULL;
  const char *db_filename = NULL;
  char *db_query = NULL;
  notmuch_database_t *db = NULL;
  enum MxStatus rc = MX_STATUS_ERROR;
  const short c_nm_db_limit = cs_subset_number(NeoMutt->sub, "nm_db_limit");
  int limit = c_nm_db_limit;
  mutt_debug(LL_DEBUG1, "nm: count\n");
 
  url = url_parse(mailbox_path(m));
  if (!url)
  {
    mutt_error(_("failed to parse notmuch url: %s"), mailbox_path(m));
    goto done;
  }
 
  STAILQ_FOREACH(item, &url->query_strings, entries)
  {
    if (item->value && (mutt_str_equal(item->name, "query")))
    {
      db_query = item->value;
    }
    else if (item->value && (mutt_str_equal(item->name, "limit")))
    {
      // Try to parse the limit
      if (!mutt_str_atoi_full(item->value, &limit))
      {
        mutt_error(_("failed to parse limit: %s"), item->value);
        goto done;
      }
    }
  }
 
  if (!db_query)
    goto done;
 
  db_filename = url->path;
  if (!db_filename)
    db_filename = nm_db_get_filename(m);
 
#if LIBNOTMUCH_CHECK_VERSION(5, 4, 0)
  /* don't be verbose about connection, as we're called from
   * sidebar/mailbox very often */
  db = nm_db_do_open(db_filename, false, false);
#else
  if (!db_filename)
  {
    const char *const c_folder = cs_subset_string(NeoMutt->sub, "folder");
    db_filename = c_folder;
  }
  /* don't be verbose about connection, as we're called from
   * sidebar/mailbox very often */
  if (db_filename)
    db = nm_db_do_open(db_filename, false, false);
#endif
  if (!db)
    goto done;
 
  /* all emails */
  m->msg_count = count_query(db, db_query, limit);
  mx_alloc_memory(m, m->msg_count);
 
  // holder variable for extending query to unread/flagged
  char *qstr = NULL;
 
  // unread messages
  const char *const c_nm_unread_tag = cs_subset_string(NeoMutt->sub, "nm_unread_tag");
  mutt_str_asprintf(&qstr, "( %s ) tag:%s", db_query, c_nm_unread_tag);
  m->msg_unread = count_query(db, qstr, limit);
  FREE(&qstr);
 
  // flagged messages
  const char *const c_nm_flagged_tag = cs_subset_string(NeoMutt->sub, "nm_flagged_tag");
  mutt_str_asprintf(&qstr, "( %s ) tag:%s", db_query, c_nm_flagged_tag);
  m->msg_flagged = count_query(db, qstr, limit);
  FREE(&qstr);
 
  rc = (m->msg_unread > 0) ? MX_STATUS_NEW_MAIL : MX_STATUS_OK;
done:
  if (db)
  {
    nm_db_free(db);
    mutt_debug(LL_DEBUG1, "nm: count close DB\n");
  }
  url_free(&url);
 
  mutt_debug(LL_DEBUG1, "nm: count done [rc=%d]\n", rc);
  return rc;
}

Here is the call graph for this function: