mbox_check()

Check for new mail. More...

Collaboration diagram for mbox_check():

Functions
static enum MxStatus	comp_mbox_check (struct Mailbox *m)
	Check for new mail - Implements MxOps::mbox_check() -.
static enum MxStatus	imap_mbox_check (struct Mailbox *m)
	Check for new mail - Implements MxOps::mbox_check() -.
enum MxStatus	maildir_mbox_check (struct Mailbox *m)
	Check for new mail - Implements MxOps::mbox_check() -.
static enum MxStatus	mbox_mbox_check (struct Mailbox *m)
	Check for new mail - Implements MxOps::mbox_check() -.
static enum MxStatus	mh_mbox_check (struct Mailbox *m)
	Check for new mail - Implements MxOps::mbox_check() -.
static enum MxStatus	nntp_mbox_check (struct Mailbox *m)
	Check for new mail - Implements MxOps::mbox_check() -.
static enum MxStatus	nm_mbox_check (struct Mailbox *m)
	Check for new mail - Implements MxOps::mbox_check() -.
static enum MxStatus	pop_mbox_check (struct Mailbox *m)
	Check for new mail - Implements MxOps::mbox_check() -.

Detailed Description

Check for new mail.

Parameters

m

Mailbox

Return values

enum

MxStatus

Precondition

m is not NULL

Function Documentation

comp_mbox_check()

static enum MxStatus comp_mbox_check ( struct Mailbox *  m )

static

Check for new mail - Implements MxOps::mbox_check() -.

Parameters

m

Mailbox

Return values

enum

MxStatus

If the compressed file changes in size but the mailbox hasn't been changed in NeoMutt, then we can close and reopen the mailbox.

If the mailbox has been changed in NeoMutt, warn the user.

Definition at line 548 of file compress.c.

{
  if (!m->compress_info)
    return MX_STATUS_ERROR;
 
  struct CompressInfo *ci = m->compress_info;
 
  const struct MxOps *ops = ci->child_ops;
  if (!ops)
    return MX_STATUS_ERROR;
 
  int size = mutt_file_get_size(m->realpath);
  if (size == ci->size)
    return MX_STATUS_OK;
 
  if (!lock_realpath(m, false))
  {
    mutt_error(_("Unable to lock mailbox"));
    return MX_STATUS_ERROR;
  }
 
  bool rc = execute_command(m, ci->cmd_open, _("Decompressing %s"));
  store_size(m);
  unlock_realpath(m);
  if (!rc)
    return MX_STATUS_ERROR;
 
  return ops->mbox_check(m);
}

Here is the call graph for this function:

Here is the caller graph for this function:

imap_mbox_check()

static enum MxStatus imap_mbox_check ( struct Mailbox *  m )

static

Check for new mail - Implements MxOps::mbox_check() -.

Parameters

m

Mailbox

Return values

>0	Success, e.g. MX_STATUS_REOPENED
-1	Failure

Definition at line 2108 of file imap.c.

{
  imap_allow_reopen(m);
  enum MxStatus rc = imap_check_mailbox(m, false);
  /* NOTE - mv might have been changed at this point. In particular,
   * m could be NULL. Beware. */
  imap_disallow_reopen(m);
 
  return rc;
}

Here is the call graph for this function:

maildir_mbox_check()

enum MxStatus maildir_mbox_check

(

struct Mailbox *

m

)

Check for new mail - Implements MxOps::mbox_check() -.

Definition at line 805 of file mailbox.c.

{
  return maildir_check(m);
}

Here is the call graph for this function:

mbox_mbox_check()

static enum MxStatus mbox_mbox_check ( struct Mailbox *  m )

static

Check for new mail - Implements MxOps::mbox_check() -.

Parameters

[in]

m

Mailbox

Return values

MX_STATUS_REOPENED	Mailbox has been reopened
MX_STATUS_NEW_MAIL	New mail has arrived
MX_STATUS_LOCKED	Couldn't lock the file

Definition at line 929 of file mbox.c.

{
  struct MboxAccountData *adata = mbox_adata_get(m);
  if (!adata)
    return MX_STATUS_ERROR;
 
  if (!adata->fp)
  {
    if (mbox_mbox_open(m) != MX_OPEN_OK)
      return MX_STATUS_ERROR;
    mailbox_changed(m, NT_MAILBOX_INVALID);
  }
  if (!adata->fp)
    return MX_STATUS_ERROR;
 
  struct stat st = { 0 };
  bool unlock = false;
  bool modified = false;
 
  if (stat(mailbox_path(m), &st) == 0)
  {
    if ((mutt_file_stat_timespec_compare(&st, MUTT_STAT_MTIME, &adata->mtime) == 0) &&
        (st.st_size == m->size))
    {
      return MX_STATUS_OK;
    }
 
    if (st.st_size == m->size)
    {
      /* the file was touched, but it is still the same length, so just exit */
      mutt_file_get_stat_timespec(&adata->mtime, &st, MUTT_STAT_MTIME);
      return MX_STATUS_OK;
    }
 
    if (st.st_size > m->size)
    {
      /* lock the file if it isn't already */
      if (!adata->locked)
      {
        mutt_sig_block();
        if (mbox_lock_mailbox(m, false, false) == -1)
        {
          mutt_sig_unblock();
          /* we couldn't lock the mailbox, but nothing serious happened:
           * probably the new mail arrived: no reason to wait till we can
           * parse it: we'll get it on the next pass */
          return MX_STATUS_LOCKED;
        }
        unlock = 1;
      }
 
      /* Check to make sure that the only change to the mailbox is that
       * message(s) were appended to this file.  My heuristic is that we should
       * see the message separator at *exactly* what used to be the end of the
       * folder.  */
      char buf[1024] = { 0 };
      if (!mutt_file_seek(adata->fp, m->size, SEEK_SET))
      {
        goto error;
      }
      if (fgets(buf, sizeof(buf), adata->fp))
      {
        if (((m->type == MUTT_MBOX) && mutt_str_startswith(buf, "From ")) ||
            ((m->type == MUTT_MMDF) && mutt_str_equal(buf, MMDF_SEP)))
        {
          if (!mutt_file_seek(adata->fp, m->size, SEEK_SET))
          {
            goto error;
          }
 
          int old_msg_count = m->msg_count;
          if (m->type == MUTT_MBOX)
            mbox_parse_mailbox(m);
          else
            mmdf_parse_mailbox(m);
 
          if (m->msg_count > old_msg_count)
            mailbox_changed(m, NT_MAILBOX_INVALID);
 
          /* Only unlock the folder if it was locked inside of this routine.
           * It may have been locked elsewhere, like in
           * mutt_checkpoint_mailbox().  */
          if (unlock)
          {
            mbox_unlock_mailbox(m);
            mutt_sig_unblock();
          }
 
          return MX_STATUS_NEW_MAIL; /* signal that new mail arrived */
        }
        else
        {
          modified = true;
        }
      }
      else
      {
        mutt_debug(LL_DEBUG1, "fgets returned NULL\n");
        modified = true;
      }
    }
    else
    {
      modified = true;
    }
  }
 
  if (modified)
  {
    if (reopen_mailbox(m) != -1)
    {
      mailbox_changed(m, NT_MAILBOX_INVALID);
      if (unlock)
      {
        mbox_unlock_mailbox(m);
        mutt_sig_unblock();
      }
      return MX_STATUS_REOPENED;
    }
  }
 
  /* fatal error */
 
error:
  mbox_unlock_mailbox(m);
  mx_fastclose_mailbox(m, false);
  mutt_sig_unblock();
  mutt_error(_("Mailbox was corrupted"));
  return MX_STATUS_ERROR;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mh_mbox_check()

static enum MxStatus mh_mbox_check ( struct Mailbox *  m )

static

Check for new mail - Implements MxOps::mbox_check() -.

Definition at line 1051 of file mh.c.

{
  return mh_check(m);
}

Here is the call graph for this function:

nntp_mbox_check()

static enum MxStatus nntp_mbox_check ( struct Mailbox *  m )

static

Check for new mail - Implements MxOps::mbox_check() -.

Parameters

m

Mailbox

Return values

enum

MxStatus

Definition at line 2547 of file nntp.c.

{
  enum MxStatus rc = check_mailbox(m);
  if (rc == MX_STATUS_OK)
  {
    struct NntpMboxData *mdata = m->mdata;
    struct NntpAccountData *adata = mdata->adata;
    nntp_newsrc_close(adata);
  }
  return rc;
}

Here is the call graph for this function:

nm_mbox_check()

static enum MxStatus nm_mbox_check ( struct Mailbox *  m )

static

Check for new mail - Implements MxOps::mbox_check() -.

Parameters

m

Mailbox

Return values

enum

MxStatus

Definition at line 2115 of file notmuch.c.

{
  struct NmMboxData *mdata = nm_mdata_get(m);
  time_t mtime = 0;
  if (!mdata || (nm_db_get_mtime(m, &mtime) != 0))
    return MX_STATUS_ERROR;
 
  int new_flags = 0;
  bool occult = false;
 
  if (mdata->mtime.tv_sec >= mtime)
  {
    mutt_debug(LL_DEBUG2, "nm: check unnecessary (db=%llu mailbox=%llu)\n",
               (unsigned long long) mtime, (unsigned long long) mdata->mtime.tv_sec);
    return MX_STATUS_OK;
  }
 
  mutt_debug(LL_DEBUG1, "nm: checking (db=%llu mailbox=%llu)\n",
             (unsigned long long) mtime, (unsigned long long) mdata->mtime.tv_sec);
 
  notmuch_query_t *q = get_query(m, false);
  if (!q)
    goto done;
 
  mutt_debug(LL_DEBUG1, "nm: start checking (count=%d)\n", m->msg_count);
  mdata->oldmsgcount = m->msg_count;
 
  for (int i = 0; i < m->msg_count; i++)
  {
    struct Email *e = m->emails[i];
    if (!e)
      break;
 
    e->active = false;
  }
 
  int limit = get_limit(mdata);
 
  notmuch_messages_t *msgs = get_messages(q);
 
  // TODO: Analyze impact of removing this version guard.
#if LIBNOTMUCH_CHECK_VERSION(5, 0, 0)
  if (!msgs)
    return MX_STATUS_OK;
#elif LIBNOTMUCH_CHECK_VERSION(4, 3, 0)
  if (!msgs)
    goto done;
#endif
 
  struct HeaderCache *hc = nm_hcache_open(m);
 
  for (int i = 0; notmuch_messages_valid(msgs) && ((limit == 0) || (i < limit));
       notmuch_messages_move_to_next(msgs), i++)
  {
    notmuch_message_t *msg = notmuch_messages_get(msgs);
    struct Email *e = get_mutt_email(m, msg);
 
    if (!e)
    {
      /* new email */
      append_message(hc, m, msg, false);
      notmuch_message_destroy(msg);
      continue;
    }
 
    /* message already exists, merge flags */
    e->active = true;
 
    /* Check to see if the message has moved to a different subdirectory.
     * If so, update the associated filename.  */
    const char *new_file = get_message_last_filename(msg);
    char old_file[PATH_MAX] = { 0 };
    email_get_fullpath(e, old_file, sizeof(old_file));
 
    if (!mutt_str_equal(old_file, new_file))
      update_message_path(e, new_file);
 
    if (!e->changed)
    {
      /* if the user hasn't modified the flags on this message, update the
       * flags we just detected.  */
      struct Email *e_tmp = maildir_email_new();
      maildir_parse_flags(e_tmp, new_file);
      e_tmp->old = e->old;
      maildir_update_flags(m, e, e_tmp);
      email_free(&e_tmp);
    }
 
    if (update_email_tags(e, msg) == 0)
      new_flags++;
 
    notmuch_message_destroy(msg);
  }
 
  nm_hcache_close(&hc);
 
  for (int i = 0; i < m->msg_count; i++)
  {
    struct Email *e = m->emails[i];
    if (!e)
      break;
 
    if (!e->active)
    {
      occult = true;
      break;
    }
  }
 
  if (m->msg_count > mdata->oldmsgcount)
    mailbox_changed(m, NT_MAILBOX_INVALID);
done:
  if (q)
    notmuch_query_destroy(q);
 
  nm_db_release(m);
 
  mdata->mtime.tv_sec = mutt_date_now();
  mdata->mtime.tv_nsec = 0;
 
  mutt_debug(LL_DEBUG1, "nm: ... check done [count=%d, new_flags=%d, occult=%d]\n",
             m->msg_count, new_flags, occult);
 
  if (occult)
    return MX_STATUS_REOPENED;
  if (m->msg_count > mdata->oldmsgcount)
    return MX_STATUS_NEW_MAIL;
  if (new_flags)
    return MX_STATUS_FLAGS;
  return MX_STATUS_OK;
}

Here is the call graph for this function:

pop_mbox_check()

static enum MxStatus pop_mbox_check ( struct Mailbox *  m )

static

Check for new mail - Implements MxOps::mbox_check() -.

Definition at line 817 of file pop.c.

{
  if (!m || !m->account)
    return MX_STATUS_ERROR;
 
  struct PopAccountData *adata = pop_adata_get(m);
 
  const short c_pop_check_interval = cs_subset_number(NeoMutt->sub, "pop_check_interval");
  if ((adata->check_time + c_pop_check_interval) > mutt_date_now())
    return MX_STATUS_OK;
 
  pop_logout(m);
 
  mutt_socket_close(adata->conn);
 
  if (pop_open_connection(adata) < 0)
    return MX_STATUS_ERROR;
 
  m->size = adata->size;
 
  mutt_message(_("Checking for new messages..."));
 
  int old_msg_count = m->msg_count;
  int rc = pop_fetch_headers(m);
  pop_clear_cache(adata);
  if (m->msg_count > old_msg_count)
    mailbox_changed(m, NT_MAILBOX_INVALID);
 
  if (rc < 0)
    return MX_STATUS_ERROR;
 
  if (rc > 0)
    return MX_STATUS_NEW_MAIL;
 
  return MX_STATUS_OK;
}

Here is the call graph for this function: