mh.c File Reference

MH local mailbox type. More...

#include "config.h"
#include <ctype.h>
#include <dirent.h>
#include <errno.h>
#include <fcntl.h>
#include <inttypes.h>
#include <limits.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "email/lib.h"
#include "core/lib.h"
#include "mutt.h"
#include "progress/lib.h"
#include "copy.h"
#include "globals.h"
#include "mdata.h"
#include "mhemail.h"
#include "mx.h"
#include "protos.h"
#include "sequence.h"
#include "shared.h"
#include "monitor.h"
#include "hcache/lib.h"

Include dependency graph for mh.c:

Go to the source code of this file.

Functions
static int	mh_already_notified (struct Mailbox *m, int msgno)
	Has the message changed.
static bool	mh_valid_message (const char *s)
	Is this a valid MH message filename.
int	mh_check_empty (struct Buffer *path)
	Is mailbox empty.
static enum MxStatus	mh_mbox_check_stats (struct Mailbox *m, uint8_t flags)
	Check the Mailbox statistics - Implements MxOps::mbox_check_stats() -.
static void	mh_update_emails (struct MhEmailArray *mha, struct MhSequences *mhs)
	Update our record of flags.
static int	mh_commit_msg (struct Mailbox *m, struct Message *msg, struct Email *e, bool updseq)
	Commit a message to an MH folder.
static int	mh_rewrite_message (struct Mailbox *m, struct Email *e)
	Sync a message in an MH folder.
static int	mh_sync_message (struct Mailbox *m, struct Email *e)
	Sync an email to an MH folder.
static void	mh_update_mtime (struct Mailbox *m)
	Update our record of the mailbox modification time.
static int	mh_parse_dir (struct Mailbox *m, struct MhEmailArray *mha, struct Progress *progress)
	Read an Mh mailbox.
static int	mh_sort_path (const void *a, const void *b, void *sdata)
	Compare two Mh Mailboxes by path - Implements sort_t -.
static struct Email *	mh_parse_message (const char *fname, struct Email *e)
	Actually parse an MH message.
static void	mh_delayed_parsing (struct Mailbox *m, struct MhEmailArray *mha, struct Progress *progress)
	This function does the second parsing pass.
static int	mh_move_to_mailbox (struct Mailbox *m, const struct MhEmailArray *mha)
	Copy the Mh list to the Mailbox.
static bool	mh_read_dir (struct Mailbox *m)
	Read an MH mailbox.
int	mh_sync_mailbox_message (struct Mailbox *m, struct Email *e, struct HeaderCache *hc)
	Save changes to the mailbox.
static int	mh_msg_save_hcache (struct Mailbox *m, struct Email *e)
	Save message to the header cache - Implements MxOps::msg_save_hcache() -.
static bool	mh_ac_owns_path (struct Account *a, const char *path)
	Check whether an Account owns a Mailbox path - Implements MxOps::ac_owns_path() -.
static bool	mh_ac_add (struct Account *a, struct Mailbox *m)
	Add a Mailbox to an Account - Implements MxOps::ac_add() -.
static enum MxOpenReturns	mh_mbox_open (struct Mailbox *m)
	Open a Mailbox - Implements MxOps::mbox_open() -.
static bool	mh_mbox_open_append (struct Mailbox *m, OpenMailboxFlags flags)
	Open a Mailbox for appending - Implements MxOps::mbox_open_append() -.
static bool	mh_update_flags (struct Mailbox *m, struct Email *e_old, struct Email *e_new)
	Update the mailbox flags.
static enum MxStatus	mh_check (struct Mailbox *m)
	Check for new mail.
static enum MxStatus	mh_mbox_check (struct Mailbox *m)
	Check for new mail - Implements MxOps::mbox_check() -.
static enum MxStatus	mh_mbox_sync (struct Mailbox *m)
	Save changes to the Mailbox - Implements MxOps::mbox_sync() -.
static enum MxStatus	mh_mbox_close (struct Mailbox *m)
	Close a Mailbox - Implements MxOps::mbox_close() -.
static bool	mh_msg_open (struct Mailbox *m, struct Message *msg, struct Email *e)
	Open an email message in a Mailbox - Implements MxOps::msg_open() -.
static bool	mh_msg_open_new (struct Mailbox *m, struct Message *msg, const struct Email *e)
	Open a new message in a Mailbox - Implements MxOps::msg_open_new() -.
static int	mh_msg_commit (struct Mailbox *m, struct Message *msg)
	Save changes to an email - Implements MxOps::msg_commit() -.
static int	mh_msg_close (struct Mailbox *m, struct Message *msg)
	Close an email - Implements MxOps::msg_close() -.
static int	mh_path_canon (struct Buffer *path)
	Canonicalise a Mailbox path - Implements MxOps::path_canon() -.
static enum MailboxType	mh_path_probe (const char *path, const struct stat *st)
	Is this an mh Mailbox? - Implements MxOps::path_probe() -.

Variables
const struct MxOps	MxMhOps
	MH Mailbox - Implements MxOps -.

Detailed Description

MH local mailbox type.

Authors

• Richard Russon
• Austin Ray
• Pietro Cerutti
• Dennis Schön

Copyright

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version.

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 mh.c.

Function Documentation

mh_already_notified()

static int mh_already_notified ( struct Mailbox *  m, int  msgno  )

static

Has the message changed.

Parameters

m	Mailbox
msgno	Message number

Return values

1	Modification time on the message file is older than the last visit to this mailbox
0	Modification time on the message file is newer
-1	Error

Definition at line 80 of file mh.c.

{
  char path[PATH_MAX] = { 0 };
  struct stat st = { 0 };
 
  if ((snprintf(path, sizeof(path), "%s/%d", mailbox_path(m), msgno) < sizeof(path)) &&
      (stat(path, &st) == 0))
  {
    return (mutt_file_stat_timespec_compare(&st, MUTT_STAT_MTIME, &m->last_visited) <= 0);
  }
  return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mh_valid_message()

static bool mh_valid_message ( const char *  s )

static

Is this a valid MH message filename.

Parameters

s	Pathname to examine

Return values

true	name is valid
false	name is invalid

Ignore the garbage files. A valid MH message consists of only digits. Deleted message get moved to a filename with a comma before it.

Definition at line 102 of file mh.c.

{
  for (; *s; s++)
  {
    if (!isdigit((unsigned char) *s))
      return false;
  }
  return true;
}

Here is the caller graph for this function:

mh_check_empty()

int mh_check_empty

(

struct Buffer *

path

)

Is mailbox empty.

Parameters

path	Mailbox to check

Return values

1	Mailbox is empty
0	Mailbox contains mail
-1	Error

Definition at line 119 of file mh.c.

{
  struct dirent *de = NULL;
  int rc = 1; /* assume empty until we find a message */
 
  DIR *dir = mutt_file_opendir(buf_string(path), MUTT_OPENDIR_NONE);
  if (!dir)
    return -1;
  while ((de = readdir(dir)))
  {
    if (mh_valid_message(de->d_name))
    {
      rc = 0;
      break;
    }
  }
  closedir(dir);
 
  return rc;
}

Here is the call graph for this function:

mh_update_emails()

static void mh_update_emails ( struct MhEmailArray *  mha, struct MhSequences *  mhs  )

static

Update our record of flags.

Parameters

mha	Mh array to update
mhs	Sequences

Definition at line 213 of file mh.c.

{
  struct MhEmail *md = NULL;
  struct MhEmail **mdp = NULL;
  ARRAY_FOREACH(mdp, mha)
  {
    md = *mdp;
    char *p = strrchr(md->email->path, '/');
    if (p)
      p++;
    else
      p = md->email->path;
 
    int i = 0;
    if (!mutt_str_atoi_full(p, &i))
      continue;
    MhSeqFlags flags = mh_seq_check(mhs, i);
 
    md->email->read = !(flags & MH_SEQ_UNSEEN);
    md->email->flagged = (flags & MH_SEQ_FLAGGED);
    md->email->replied = (flags & MH_SEQ_REPLIED);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mh_commit_msg()

static int mh_commit_msg ( struct Mailbox *  m, struct Message *  msg, struct Email *  e, bool  updseq  )

static

Commit a message to an MH folder.

Parameters

m	Mailbox
msg	Message to commit
e	Email
updseq	If true, update the sequence number

Return values

0	Success
-1	Failure

Definition at line 246 of file mh.c.

{
  struct dirent *de = NULL;
  char *cp = NULL, *dep = NULL;
  unsigned int n, hi = 0;
  char path[PATH_MAX] = { 0 };
  char tmp[16] = { 0 };
 
  if (mutt_file_fsync_close(&msg->fp))
  {
    mutt_perror(_("Could not flush message to disk"));
    return -1;
  }
 
  DIR *dir = mutt_file_opendir(mailbox_path(m), MUTT_OPENDIR_NONE);
  if (!dir)
  {
    mutt_perror("%s", mailbox_path(m));
    return -1;
  }
 
  /* figure out what the next message number is */
  while ((de = readdir(dir)))
  {
    dep = de->d_name;
    if (*dep == ',')
      dep++;
    cp = dep;
    while (*cp)
    {
      if (!isdigit((unsigned char) *cp))
        break;
      cp++;
    }
    if (*cp == '\0')
    {
      if (!mutt_str_atoui(dep, &n))
        mutt_debug(LL_DEBUG2, "Invalid MH message number '%s'\n", dep);
      if (n > hi)
        hi = n;
    }
  }
  closedir(dir);
 
  /* Now try to rename the file to the proper name.
   * Note: We may have to try multiple times, until we find a free slot.  */
 
  while (true)
  {
    hi++;
    snprintf(tmp, sizeof(tmp), "%u", hi);
    snprintf(path, sizeof(path), "%s/%s", mailbox_path(m), tmp);
    if (mutt_file_safe_rename(msg->path, path) == 0)
    {
      if (e)
        mutt_str_replace(&e->path, tmp);
      mutt_str_replace(&msg->committed_path, path);
      FREE(&msg->path);
      break;
    }
    else if (errno != EEXIST)
    {
      mutt_perror("%s", mailbox_path(m));
      return -1;
    }
  }
  if (updseq)
  {
    mh_seq_add_one(m, hi, !msg->flags.read, msg->flags.flagged, msg->flags.replied);
  }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mh_rewrite_message()

static int mh_rewrite_message ( struct Mailbox *  m, struct Email *  e  )

static

Sync a message in an MH folder.

Parameters

m	Mailbox
e	Email

Return values

0	Success
-1	Error

Definition at line 326 of file mh.c.

{
  if (!m || !e)
    return -1;
 
  bool restore = true;
 
  long old_body_offset = e->body->offset;
  long old_body_length = e->body->length;
  long old_hdr_lines = e->lines;
 
  struct Message *src = mx_msg_open(m, e);
  struct Message *dest = mx_msg_open_new(m, e, MUTT_MSG_NO_FLAGS);
  if (!src || !dest)
    return -1;
 
  int rc = mutt_copy_message(dest->fp, e, src, MUTT_CM_UPDATE, CH_UPDATE | CH_UPDATE_LEN, 0);
  if (rc == 0)
  {
    char oldpath[PATH_MAX] = { 0 };
    char partpath[PATH_MAX] = { 0 };
    snprintf(oldpath, sizeof(oldpath), "%s/%s", mailbox_path(m), e->path);
    mutt_str_copy(partpath, e->path, sizeof(partpath));
 
    rc = mh_commit_msg(m, dest, e, false);
 
    if (rc == 0)
    {
      unlink(oldpath);
      restore = false;
    }
 
    /* Try to move the new message to the old place.
     * (MH only.)
     *
     * This is important when we are just updating flags.
     *
     * Note that there is a race condition against programs which
     * use the first free slot instead of the maximum message
     * number.  NeoMutt does _not_ behave like this.
     *
     * Anyway, if this fails, the message is in the folder, so
     * all what happens is that a concurrently running neomutt will
     * lose flag modifications.  */
    if (rc == 0)
    {
      char newpath[PATH_MAX] = { 0 };
      snprintf(newpath, sizeof(newpath), "%s/%s", mailbox_path(m), e->path);
      rc = mutt_file_safe_rename(newpath, oldpath);
      if (rc == 0)
        mutt_str_replace(&e->path, partpath);
    }
  }
  mx_msg_close(m, &src);
  mx_msg_close(m, &dest);
 
  if ((rc == -1) && restore)
  {
    e->body->offset = old_body_offset;
    e->body->length = old_body_length;
    e->lines = old_hdr_lines;
  }
 
  mutt_body_free(&e->body->parts);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mh_sync_message()

static int mh_sync_message ( struct Mailbox *  m, struct Email *  e  )

static

Sync an email to an MH folder.

Parameters

m	Mailbox
e	Email

Return values

0	Success
-1	Error

Definition at line 400 of file mh.c.

{
  if (!m || !e)
    return -1;
 
  if (e->attach_del || e->env->changed)
  {
    if (mh_rewrite_message(m, e) != 0)
      return -1;
    e->env->changed = false;
  }
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mh_update_mtime()

static void mh_update_mtime ( struct Mailbox *  m )

static

Update our record of the mailbox modification time.

Parameters

m

Mailbox

Definition at line 419 of file mh.c.

{
  char buf[PATH_MAX] = { 0 };
  struct stat st = { 0 };
  struct MhMboxData *mdata = mh_mdata_get(m);
 
  snprintf(buf, sizeof(buf), "%s/.mh_sequences", mailbox_path(m));
  if (stat(buf, &st) == 0)
    mutt_file_get_stat_timespec(&mdata->mtime_seq, &st, MUTT_STAT_MTIME);
 
  mutt_str_copy(buf, mailbox_path(m), sizeof(buf));
 
  if (stat(buf, &st) == 0)
    mutt_file_get_stat_timespec(&mdata->mtime, &st, MUTT_STAT_MTIME);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mh_parse_dir()

static int mh_parse_dir ( struct Mailbox *  m, struct MhEmailArray *  mha, struct Progress *  progress  )

static

Read an Mh mailbox.

Parameters

[in]	m	Mailbox
[out]	mha	Array for results
[in]	progress	Progress bar

Return values

0	Success
-1	Error
-2	Aborted

Definition at line 444 of file mh.c.

{
  struct dirent *de = NULL;
  int rc = 0;
  struct MhEmail *entry = NULL;
  struct Email *e = NULL;
 
  struct Buffer *buf = buf_pool_get();
  buf_strcpy(buf, mailbox_path(m));
 
  DIR *dir = mutt_file_opendir(buf_string(buf), MUTT_OPENDIR_NONE);
  if (!dir)
  {
    rc = -1;
    goto cleanup;
  }
 
  while (((de = readdir(dir))) && !SigInt)
  {
    if (!mh_valid_message(de->d_name))
      continue;
 
    mutt_debug(LL_DEBUG2, "queueing %s\n", de->d_name);
 
    e = email_new();
 
    progress_update(progress, ARRAY_SIZE(mha) + 1, -1);
 
    e->path = mutt_str_dup(de->d_name);
 
    entry = mh_entry_new();
    entry->email = e;
    ARRAY_ADD(mha, entry);
  }
 
  closedir(dir);
 
  if (SigInt)
  {
    SigInt = false;
    return -2; /* action aborted */
  }
 
cleanup:
  buf_pool_release(&buf);
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mh_parse_message()

static struct Email * mh_parse_message ( const char *  fname, struct Email *  e  )

static

Actually parse an MH message.

Parameters

fname	Message filename
e	Email to populate (OPTIONAL)

Return values

ptr	Populated Email

This may also be used to fill out a fake header structure generated by lazy mh parsing.

Definition at line 512 of file mh.c.

{
  FILE *fp = mutt_file_fopen(fname, "r");
  if (!fp)
  {
    return NULL;
  }
 
  const long size = mutt_file_get_size_fp(fp);
  if (size == 0)
  {
    mutt_file_fclose(&fp);
    return NULL;
  }
 
  if (!e)
    e = email_new();
 
  e->env = mutt_rfc822_read_header(fp, e, false, false);
 
  if (e->received != 0)
    e->received = e->date_sent;
 
  /* always update the length since we have fresh information available. */
  e->body->length = size - e->body->offset;
  e->index = -1;
 
  mutt_file_fclose(&fp);
  return e;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mh_delayed_parsing()

static void mh_delayed_parsing ( struct Mailbox *  m, struct MhEmailArray *  mha, struct Progress *  progress  )

static

This function does the second parsing pass.

Parameters

[in]	m	Mailbox
[out]	mha	Mh array to parse
[in]	progress	Progress bar

Definition at line 549 of file mh.c.

{
  char fn[PATH_MAX] = { 0 };
 
#ifdef USE_HCACHE
  const char *const c_header_cache = cs_subset_path(NeoMutt->sub, "header_cache");
  struct HeaderCache *hc = hcache_open(c_header_cache, mailbox_path(m), NULL, true);
#endif
 
  struct MhEmail *md = NULL;
  struct MhEmail **mdp = NULL;
  ARRAY_FOREACH(mdp, mha)
  {
    md = *mdp;
    if (!md || !md->email || md->header_parsed)
      continue;
 
    progress_update(progress, ARRAY_FOREACH_IDX, -1);
 
#ifdef USE_HCACHE
    const char *key = md->email->path;
    size_t keylen = strlen(key);
    struct HCacheEntry hce = hcache_fetch_email(hc, key, keylen, 0);
 
    if (hce.email)
    {
      hce.email->old = md->email->old;
      hce.email->path = mutt_str_dup(md->email->path);
      email_free(&md->email);
      md->email = hce.email;
    }
    else
#endif
    {
      snprintf(fn, sizeof(fn), "%s/%s", mailbox_path(m), md->email->path);
 
      if (mh_parse_message(fn, md->email))
      {
        md->header_parsed = true;
#ifdef USE_HCACHE
        key = md->email->path;
        keylen = strlen(key);
        hcache_store_email(hc, key, keylen, md->email, 0);
#endif
      }
      else
      {
        email_free(&md->email);
      }
    }
  }
#ifdef USE_HCACHE
  hcache_close(&hc);
#endif
 
  const enum EmailSortType c_sort = cs_subset_sort(NeoMutt->sub, "sort");
  if (m && mha && (ARRAY_SIZE(mha) > 0) && (c_sort == EMAIL_SORT_UNSORTED))
  {
    mutt_debug(LL_DEBUG3, "mh: sorting %s into natural order\n", mailbox_path(m));
    ARRAY_SORT(mha, mh_sort_path, NULL);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mh_move_to_mailbox()

static int mh_move_to_mailbox ( struct Mailbox *  m, const struct MhEmailArray *  mha  )

static

Copy the Mh list to the Mailbox.

Parameters

[in]	m	Mailbox
[out]	mha	Mh array to copy, then free

Return values

num	Number of new emails
0	Error

Definition at line 620 of file mh.c.

{
  if (!m)
    return 0;
 
  int oldmsgcount = m->msg_count;
 
  struct MhEmail *md = NULL;
  struct MhEmail **mdp = NULL;
  ARRAY_FOREACH(mdp, mha)
  {
    md = *mdp;
    mutt_debug(LL_DEBUG2, "Considering %s\n", NONULL(md->canon_fname));
    if (!md->email)
      continue;
 
    mutt_debug(LL_DEBUG2, "Adding header structure. Flags: %s%s%s%s%s\n",
               md->email->flagged ? "f" : "", md->email->deleted ? "D" : "",
               md->email->replied ? "r" : "", md->email->old ? "O" : "",
               md->email->read ? "R" : "");
    mx_alloc_memory(m, m->msg_count);
 
    m->emails[m->msg_count] = md->email;
    m->emails[m->msg_count]->index = m->msg_count;
    mailbox_size_add(m, md->email);
 
    md->email = NULL;
    m->msg_count++;
  }
 
  int num = 0;
  if (m->msg_count > oldmsgcount)
    num = m->msg_count - oldmsgcount;
 
  return num;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mh_read_dir()

static bool mh_read_dir ( struct Mailbox *  m )

static

Read an MH mailbox.

Parameters

m

Mailbox

Return values

true	Success
false	Error

Definition at line 663 of file mh.c.

{
  if (!m)
    return false;
 
  mutt_path_tidy(&m->pathbuf, true);
 
  struct MhSequences mhs = { 0 };
  struct Progress *progress = NULL;
 
  if (m->verbose)
  {
    progress = progress_new(MUTT_PROGRESS_READ, 0);
    progress_set_message(progress, _("Scanning %s..."), mailbox_path(m));
  }
 
  struct MhMboxData *mdata = mh_mdata_get(m);
  if (!mdata)
  {
    mdata = mh_mdata_new();
    m->mdata = mdata;
    m->mdata_free = mh_mdata_free;
  }
 
  mh_update_mtime(m);
 
  struct MhEmailArray mha = ARRAY_HEAD_INITIALIZER;
  int rc = mh_parse_dir(m, &mha, progress);
  progress_free(&progress);
  if (rc < 0)
    return false;
 
  if (m->verbose)
  {
    progress = progress_new(MUTT_PROGRESS_READ, ARRAY_SIZE(&mha));
    progress_set_message(progress, _("Reading %s..."), mailbox_path(m));
  }
  mh_delayed_parsing(m, &mha, progress);
  progress_free(&progress);
 
  if (mh_seq_read(&mhs, mailbox_path(m)) < 0)
  {
    mharray_clear(&mha);
    return false;
  }
  mh_update_emails(&mha, &mhs);
  mh_seq_free(&mhs);
 
  mh_move_to_mailbox(m, &mha);
  mharray_clear(&mha);
 
  if (!mdata->umask)
    mdata->umask = mh_umask(m);
 
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mh_sync_mailbox_message()

int mh_sync_mailbox_message	(	struct Mailbox *	m,
		struct Email *	e,
		struct HeaderCache *	hc
	)

Save changes to the mailbox.

Parameters

m	Mailbox
e	Email
hc	Header cache handle

Return values

0	Success
-1	Error

Definition at line 728 of file mh.c.

{
  if (!m || !e)
    return -1;
 
  if (e->deleted)
  {
    char path[PATH_MAX] = { 0 };
    snprintf(path, sizeof(path), "%s/%s", mailbox_path(m), e->path);
    const bool c_mh_purge = cs_subset_bool(NeoMutt->sub, "mh_purge");
    if (c_mh_purge)
    {
#ifdef USE_HCACHE
      if (hc)
      {
        const char *key = e->path;
        size_t keylen = strlen(key);
        hcache_delete_email(hc, key, keylen);
      }
#endif
      unlink(path);
    }
    else
    {
      /* MH just moves files out of the way when you delete them */
      if (*e->path != ',')
      {
        char tmp[PATH_MAX] = { 0 };
        snprintf(tmp, sizeof(tmp), "%s/,%s", mailbox_path(m), e->path);
        unlink(tmp);
        if (rename(path, tmp) != 0)
        {
          return -1;
        }
      }
    }
  }
  else if (e->changed || e->attach_del)
  {
    if (mh_sync_message(m, e) == -1)
      return -1;
  }
 
#ifdef USE_HCACHE
  if (hc && e->changed)
  {
    const char *key = e->path;
    size_t keylen = strlen(key);
    hcache_store_email(hc, key, keylen, e, 0);
  }
#endif
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mh_update_flags()

static bool mh_update_flags ( struct Mailbox *  m, struct Email *  e_old, struct Email *  e_new  )

static

Update the mailbox flags.

Parameters

m	Mailbox
e_old	Old Email
e_new	New Email

Return values

true	The flags changed
false	Otherwise

Definition at line 858 of file mh.c.

{
  if (!m)
    return false;
 
  /* save the global state here so we can reset it at the
   * end of list block if required.  */
  bool context_changed = m->changed;
 
  /* user didn't modify this message.  alter the flags to match the
   * current state on disk.  This may not actually do
   * anything. mutt_set_flag() will just ignore the call if the status
   * bits are already properly set, but it is still faster not to pass
   * through it */
  if (e_old->flagged != e_new->flagged)
    mutt_set_flag(m, e_old, MUTT_FLAG, e_new->flagged, true);
  if (e_old->replied != e_new->replied)
    mutt_set_flag(m, e_old, MUTT_REPLIED, e_new->replied, true);
  if (e_old->read != e_new->read)
    mutt_set_flag(m, e_old, MUTT_READ, e_new->read, true);
  if (e_old->old != e_new->old)
    mutt_set_flag(m, e_old, MUTT_OLD, e_new->old, true);
 
  /* mutt_set_flag() will set this, but we don't need to
   * sync the changes we made because we just updated the
   * context to match the current on-disk state of the
   * message.  */
  bool header_changed = e_old->changed;
  e_old->changed = false;
 
  /* if the mailbox was not modified before we made these
   * changes, unset the changed flag since nothing needs to
   * be synchronized.  */
  if (!context_changed)
    m->changed = false;
 
  return header_changed;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mh_check()

static enum MxStatus mh_check ( struct Mailbox *  m )

static

Check for new mail.

Parameters

m

Mailbox

Return values

enum

MxStatus

This function handles arrival of new mail and reopening of mh folders. Things are getting rather complex because we don't have a well-defined "mailbox order", so the tricks from mbox.c and mx.c won't work here.

Don't change this code unless you really understand what happens.

Definition at line 909 of file mh.c.

{
  char buf[PATH_MAX] = { 0 };
  struct stat st = { 0 };
  struct stat st_cur = { 0 };
  bool modified = false, occult = false, flags_changed = false;
  int num_new = 0;
  struct MhSequences mhs = { 0 };
  struct HashTable *fnames = NULL;
  struct MhMboxData *mdata = mh_mdata_get(m);
 
  const bool c_check_new = cs_subset_bool(NeoMutt->sub, "check_new");
  if (!c_check_new)
    return MX_STATUS_OK;
 
  mutt_str_copy(buf, mailbox_path(m), sizeof(buf));
  if (stat(buf, &st) == -1)
    return MX_STATUS_ERROR;
 
  /* create .mh_sequences when there isn't one. */
  snprintf(buf, sizeof(buf), "%s/.mh_sequences", mailbox_path(m));
  int rc = stat(buf, &st_cur);
  if ((rc == -1) && (errno == ENOENT))
  {
    char *tmp = NULL;
    FILE *fp = NULL;
 
    if (mh_mkstemp(m, &fp, &tmp))
    {
      mutt_file_fclose(&fp);
      if (mutt_file_safe_rename(tmp, buf) == -1)
        unlink(tmp);
      FREE(&tmp);
    }
  }
 
  if ((rc == -1) && (stat(buf, &st_cur) == -1))
    modified = true;
 
  if ((mutt_file_stat_timespec_compare(&st, MUTT_STAT_MTIME, &mdata->mtime) > 0) ||
      (mutt_file_stat_timespec_compare(&st_cur, MUTT_STAT_MTIME, &mdata->mtime_seq) > 0))
  {
    modified = true;
  }
 
  if (!modified)
    return MX_STATUS_OK;
 
  /* Update the modification times on the mailbox.
   *
   * The monitor code notices changes in the open mailbox too quickly.
   * In practice, this sometimes leads to all the new messages not being
   * noticed during the SAME group of mtime stat updates.  To work around
   * the problem, don't update the stat times for a monitor caused check. */
#ifdef USE_INOTIFY
  if (MonitorCurMboxChanged)
  {
    MonitorCurMboxChanged = false;
  }
  else
#endif
  {
    mutt_file_get_stat_timespec(&mdata->mtime_seq, &st_cur, MUTT_STAT_MTIME);
    mutt_file_get_stat_timespec(&mdata->mtime, &st, MUTT_STAT_MTIME);
  }
 
  struct MhEmailArray mha = ARRAY_HEAD_INITIALIZER;
 
  mh_parse_dir(m, &mha, NULL);
  mh_delayed_parsing(m, &mha, NULL);
 
  if (mh_seq_read(&mhs, mailbox_path(m)) < 0)
    return MX_STATUS_ERROR;
  mh_update_emails(&mha, &mhs);
  mh_seq_free(&mhs);
 
  /* check for modifications and adjust flags */
  fnames = mutt_hash_new(ARRAY_SIZE(&mha), MUTT_HASH_NO_FLAGS);
 
  struct MhEmail *md = NULL;
  struct MhEmail **mdp = NULL;
  ARRAY_FOREACH(mdp, &mha)
  {
    md = *mdp;
    /* the hash key must survive past the header, which is freed below. */
    md->canon_fname = mutt_str_dup(md->email->path);
    mutt_hash_insert(fnames, md->canon_fname, md);
  }
 
  for (int i = 0; i < m->msg_count; i++)
  {
    struct Email *e = m->emails[i];
    if (!e)
      break;
 
    md = mutt_hash_find(fnames, e->path);
    if (md && md->email && email_cmp_strict(e, md->email))
    {
      /* found the right message */
      if (!e->changed)
        if (mh_update_flags(m, e, md->email))
          flags_changed = true;
 
      email_free(&md->email);
    }
    else /* message has disappeared */
    {
      occult = true;
    }
  }
 
  /* destroy the file name hash */
 
  mutt_hash_free(&fnames);
 
  /* If we didn't just get new mail, update the tables. */
  if (occult)
    mailbox_changed(m, NT_MAILBOX_RESORT);
 
  /* Incorporate new messages */
  num_new = mh_move_to_mailbox(m, &mha);
  mharray_clear(&mha);
 
  if (num_new > 0)
  {
    mailbox_changed(m, NT_MAILBOX_INVALID);
    m->changed = true;
  }
 
  ARRAY_FREE(&mha);
  if (occult)
    return MX_STATUS_REOPENED;
  if (num_new > 0)
    return MX_STATUS_NEW_MAIL;
  if (flags_changed)
    return MX_STATUS_FLAGS;
  return MX_STATUS_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function: