mailbox.c File Reference

Maildir Mailbox. More...

#include "config.h"
#include <dirent.h>
#include <errno.h>
#include <limits.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 "mailbox.h"
#include "progress/lib.h"
#include "edata.h"
#include "hcache.h"
#include "mdata.h"
#include "mdemail.h"
#include "mx.h"
#include "shared.h"
#include "monitor.h"

Include dependency graph for mailbox.c:

Go to the source code of this file.

Macros
#define	MMC_NO_DIRS   0
	No directories changed.
#define	MMC_NEW_DIR   (1 << 0)
	'new' directory changed
#define	MMC_CUR_DIR   (1 << 1)
	'cur' directory changed

Functions
struct Email *	maildir_email_new (void)
	Create a Maildir Email.
void	maildir_parse_flags (struct Email *e, const char *path)
	Parse Maildir file flags.
bool	maildir_parse_stream (FILE *fp, const char *fname, bool is_old, struct Email *e)
	Parse a Maildir message.
bool	maildir_parse_message (const char *fname, bool is_old, struct Email *e)
	Actually parse a maildir message.
static int	maildir_move_to_mailbox (struct Mailbox *m, const struct MdEmailArray *mda)
	Copy the Maildir list to the Mailbox.
static int	maildir_sort_inode (const void *a, const void *b, void *sdata)
	Compare two Maildirs by inode number - Implements sort_t -.
static int	maildir_parse_dir (struct Mailbox *m, struct MdEmailArray *mda, const char *subdir, struct Progress *progress)
	Read a Maildir mailbox.
static void	maildir_delayed_parsing (struct Mailbox *m, struct MdEmailArray *mda, struct Progress *progress)
	This function does the second parsing pass.
static void	maildir_check_dir (struct Mailbox *m, const char *dir_name, bool check_new, bool check_stats)
	Check for new mail / mail counts.
static int	maildir_read_dir (struct Mailbox *m, const char *subdir)
	Read a Maildir style mailbox.
static enum MxStatus	maildir_check (struct Mailbox *m)
	Check for new mail.
void	maildir_update_mtime (struct Mailbox *m)
	Update our record of the Maildir modification time.
enum MxOpenReturns	maildir_mbox_open (struct Mailbox *m)
	Open a Mailbox - Implements MxOps::mbox_open() -.
bool	maildir_mbox_open_append (struct Mailbox *m, OpenMailboxFlags flags)
	Open a Mailbox for appending - Implements MxOps::mbox_open_append() -.
enum MxStatus	maildir_mbox_check (struct Mailbox *m)
	Check for new mail - Implements MxOps::mbox_check() -.
enum MxStatus	maildir_mbox_check_stats (struct Mailbox *m, uint8_t flags)
	Check the Mailbox statistics - Implements MxOps::mbox_check_stats() -.
enum MxStatus	maildir_mbox_sync (struct Mailbox *m)
	Save changes to the Mailbox - Implements MxOps::mbox_sync() -.
enum MxStatus	maildir_mbox_close (struct Mailbox *m)
	Close a Mailbox - Implements MxOps::mbox_close() -.

Detailed Description

Maildir Mailbox.

Authors

• Richard Russon
• Pietro Cerutti

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

Macro Definition Documentation

MMC_NO_DIRS

#define MMC_NO_DIRS   0

No directories changed.

Definition at line 56 of file mailbox.c.

MMC_NEW_DIR

#define MMC_NEW_DIR   (1 << 0)

'new' directory changed

Definition at line 57 of file mailbox.c.

MMC_CUR_DIR

#define MMC_CUR_DIR   (1 << 1)

'cur' directory changed

Definition at line 58 of file mailbox.c.

Function Documentation

maildir_email_new()

struct Email * maildir_email_new

(

void

)

Create a Maildir Email.

Return values

ptr	Newly created Email

Create a new Email and attach MaildirEmailData.

Note

This should be freed using email_free()

Definition at line 68 of file mailbox.c.

{
  struct Email *e = email_new();
  e->edata = maildir_edata_new();
  e->edata_free = maildir_edata_free;
 
  return e;
}

Here is the call graph for this function:

Here is the caller graph for this function:

maildir_parse_flags()

void maildir_parse_flags	(	struct Email *	e,
		const char *	path )

Parse Maildir file flags.

Parameters

e	Email
path	Path to email file

Definition at line 82 of file mailbox.c.

{
  char *q = NULL;
 
  e->flagged = false;
  e->read = false;
  e->replied = false;
 
  struct MaildirEmailData *edata = maildir_edata_get(e);
  if (!edata)
  {
    e->edata = maildir_edata_new();
    edata = e->edata;
  }
 
  const char c_maildir_field_delimiter = *cc_maildir_field_delimiter();
  char *p = strrchr(path, c_maildir_field_delimiter);
  if (p && mutt_str_startswith(p + 1, "2,"))
  {
    p += 3;
 
    mutt_str_replace(&edata->custom_flags, p);
    q = edata->custom_flags;
 
    while (*p)
    {
      switch (*p)
      {
        case 'F': // Flagged
          e->flagged = true;
          break;
 
        case 'R': // Replied
          e->replied = true;
          break;
 
        case 'S': // Seen
          e->read = true;
          break;
 
        case 'T': // Trashed
        {
          const bool c_flag_safe = cs_subset_bool(NeoMutt->sub, "flag_safe");
          if (!e->flagged || !c_flag_safe)
          {
            e->trash = true;
            e->deleted = true;
          }
          break;
        }
 
        default:
          *q++ = *p;
          break;
      }
      p++;
    }
  }
 
  if (q == edata->custom_flags)
    FREE(&edata->custom_flags);
  else if (q)
    *q = '\0';
}

Here is the call graph for this function:

Here is the caller graph for this function:

maildir_parse_stream()

bool maildir_parse_stream	(	FILE *	fp,
		const char *	fname,
		bool	is_old,
		struct Email *	e )

Parse a Maildir message.

Parameters

fp	Message file handle
fname	Message filename
is_old	true, if the email is old (read)
e	Email

Return values

true

Success

Actually parse a maildir message. This may also be used to fill out a fake header structure generated by lazy maildir parsing.

Definition at line 158 of file mailbox.c.

{
  if (!fp || !fname || !e)
    return false;
 
  const long size = mutt_file_get_size_fp(fp);
  if (size == 0)
    return false;
 
  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;
 
  /* maildir stores its flags in the filename, so ignore the
   * flags in the header of the message */
  e->old = is_old;
  maildir_parse_flags(e, fname);
 
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

maildir_parse_message()

bool maildir_parse_message	(	const char *	fname,
		bool	is_old,
		struct Email *	e )

Actually parse a maildir message.

Parameters

fname	Message filename
is_old	true, if the email is old (read)
e	Email to populate

Return values

true

Success

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

Definition at line 195 of file mailbox.c.

{
  if (!fname || !e)
    return false;
 
  FILE *fp = mutt_file_fopen(fname, "r");
  if (!fp)
    return false;
 
  bool rc = maildir_parse_stream(fp, fname, is_old, e);
  mutt_file_fclose(&fp);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

maildir_move_to_mailbox()

static int maildir_move_to_mailbox ( struct Mailbox * m, const struct MdEmailArray * mda )

static

Copy the Maildir list to the Mailbox.

Parameters

[in]	m	Mailbox
[out]	mda	Maildir array to copy, then free

Return values

num	Number of new emails
0	Error

Definition at line 216 of file mailbox.c.

{
  if (!m)
    return 0;
 
  int oldmsgcount = m->msg_count;
 
  struct MdEmail *md = NULL;
  struct MdEmail **mdp = NULL;
  ARRAY_FOREACH(mdp, mda)
  {
    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:

maildir_parse_dir()

static int maildir_parse_dir ( struct Mailbox * m, struct MdEmailArray * mda, const char * subdir, struct Progress * progress )

static

Read a Maildir mailbox.

Parameters

[in]	m	Mailbox
[out]	mda	Array for results
[in]	subdir	Subdirectory, e.g. 'new'
[in]	progress	Progress bar

Return values

0	Success
-1	Error
-2	Aborted

Definition at line 274 of file mailbox.c.

{
  struct dirent *de = NULL;
  int rc = 0;
  bool is_old = false;
  struct MdEmail *entry = NULL;
  struct Email *e = NULL;
 
  struct Buffer *buf = buf_pool_get();
 
  buf_printf(buf, "%s/%s", mailbox_path(m), subdir);
  is_old = mutt_str_equal("cur", subdir);
 
  DIR *dir = mutt_file_opendir(buf_string(buf), MUTT_OPENDIR_CREATE);
  if (!dir)
  {
    rc = -1;
    goto cleanup;
  }
 
  while (((de = readdir(dir))) && !SigInt)
  {
    if (*de->d_name == '.')
      continue;
 
    mutt_debug(LL_DEBUG2, "queueing %s\n", de->d_name);
 
    e = maildir_email_new();
    e->old = is_old;
    maildir_parse_flags(e, de->d_name);
 
    progress_update(progress, ARRAY_SIZE(mda) + 1, -1);
 
    buf_printf(buf, "%s/%s", subdir, de->d_name);
    e->path = buf_strdup(buf);
 
    entry = maildir_entry_new();
    entry->email = e;
    entry->inode = de->d_ino;
    ARRAY_ADD(mda, entry);
  }
 
  closedir(dir);
 
  if (SigInt)
  {
    SigInt = false;
    rc = -2; /* action aborted */
    goto cleanup;
  }
 
  ARRAY_SORT(mda, maildir_sort_inode, NULL);
 
cleanup:
  buf_pool_release(&buf);
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

maildir_delayed_parsing()

static void maildir_delayed_parsing ( struct Mailbox * m, struct MdEmailArray * mda, struct Progress * progress )

static

This function does the second parsing pass.

Parameters

[in]	m	Mailbox
[out]	mda	Maildir array to parse
[in]	progress	Progress bar

Definition at line 340 of file mailbox.c.

{
  char fn[PATH_MAX] = { 0 };
 
  struct HeaderCache *hc = maildir_hcache_open(m);
 
  struct MdEmail *md = NULL;
  struct MdEmail **mdp = NULL;
  ARRAY_FOREACH(mdp, mda)
  {
    md = *mdp;
    if (!md || !md->email || md->header_parsed)
      continue;
 
    progress_update(progress, ARRAY_FOREACH_IDX_mdp, -1);
 
    snprintf(fn, sizeof(fn), "%s/%s", mailbox_path(m), md->email->path);
 
    struct Email *e = maildir_hcache_read(hc, md->email, fn);
    if (e)
    {
      email_free(&md->email);
      md->email = e;
    }
    else
    {
      if (maildir_parse_message(fn, md->email->old, md->email))
      {
        md->header_parsed = true;
        maildir_hcache_store(hc, md->email);
      }
      else
      {
        email_free(&md->email);
      }
    }
  }
 
  maildir_hcache_close(&hc);
}

Here is the call graph for this function:

Here is the caller graph for this function:

maildir_check_dir()

static void maildir_check_dir ( struct Mailbox * m, const char * dir_name, bool check_new, bool check_stats )

static

Check for new mail / mail counts.

Parameters

m	Mailbox to check
dir_name	Path to Mailbox
check_new	if true, check for new mail
check_stats	if true, count total, new, and flagged messages

Checks the specified maildir subdir (cur or new) for new mail or mail counts.

Definition at line 391 of file mailbox.c.

{
  DIR *dir = NULL;
  struct dirent *de = NULL;
  char *p = NULL;
  struct stat st = { 0 };
 
  struct Buffer *path = buf_pool_get();
  struct Buffer *msgpath = buf_pool_get();
  buf_printf(path, "%s/%s", mailbox_path(m), dir_name);
 
  /* when $mail_check_recent is set, if the new/ directory hasn't been modified since
   * the user last exited the mailbox, then we know there is no recent mail.  */
  const bool c_mail_check_recent = cs_subset_bool(NeoMutt->sub, "mail_check_recent");
  if (check_new && c_mail_check_recent)
  {
    if ((stat(buf_string(path), &st) == 0) &&
        (mutt_file_stat_timespec_compare(&st, MUTT_STAT_MTIME, &m->last_visited) < 0))
    {
      check_new = false;
    }
  }
 
  if (!(check_new || check_stats))
    goto cleanup;
 
  dir = mutt_file_opendir(buf_string(path), MUTT_OPENDIR_CREATE);
  if (!dir)
  {
    m->type = MUTT_UNKNOWN;
    goto cleanup;
  }
 
  const char c_maildir_field_delimiter = *cc_maildir_field_delimiter();
 
  char delimiter_version[8] = { 0 };
  snprintf(delimiter_version, sizeof(delimiter_version), "%c2,", c_maildir_field_delimiter);
  while ((de = readdir(dir)))
  {
    if (*de->d_name == '.')
      continue;
 
    p = strstr(de->d_name, delimiter_version);
    if (p && strchr(p + 3, 'T'))
      continue;
 
    if (check_stats)
    {
      m->msg_count++;
      if (p && strchr(p + 3, 'F'))
        m->msg_flagged++;
    }
    if (!p || !strchr(p + 3, 'S'))
    {
      if (check_stats)
        m->msg_unread++;
      if (check_new)
      {
        if (c_mail_check_recent)
        {
          buf_printf(msgpath, "%s/%s", buf_string(path), de->d_name);
          /* ensure this message was received since leaving this m */
          if ((stat(buf_string(msgpath), &st) == 0) &&
              (mutt_file_stat_timespec_compare(&st, MUTT_STAT_CTIME, &m->last_visited) <= 0))
          {
            continue;
          }
        }
        m->has_new = true;
        if (check_stats)
        {
          m->msg_new++;
        }
        else
        {
          break;
        }
      }
    }
  }
 
  closedir(dir);
 
cleanup:
  buf_pool_release(&path);
  buf_pool_release(&msgpath);
}

Here is the call graph for this function:

Here is the caller graph for this function:

maildir_read_dir()

static int maildir_read_dir ( struct Mailbox * m, const char * subdir )

static

Read a Maildir style mailbox.

Parameters

m	Mailbox
subdir	Subdir of the maildir mailbox to read from

Return values

0	Success
-1	Failure

Definition at line 487 of file mailbox.c.

{
  if (!m)
    return -1;
 
  mutt_path_tidy(&m->pathbuf, true);
 
  struct Progress *progress = NULL;
 
  if (m->verbose)
  {
    progress = progress_new(MUTT_PROGRESS_READ, 0);
    progress_set_message(progress, _("Scanning %s..."), mailbox_path(m));
  }
 
  struct MaildirMboxData *mdata = maildir_mdata_get(m);
  if (!mdata)
  {
    mdata = maildir_mdata_new();
    m->mdata = mdata;
    m->mdata_free = maildir_mdata_free;
  }
 
  struct MdEmailArray mda = ARRAY_HEAD_INITIALIZER;
  int rc = maildir_parse_dir(m, &mda, subdir, progress);
  progress_free(&progress);
  if (rc < 0)
    return -1;
 
  if (m->verbose)
  {
    progress = progress_new(MUTT_PROGRESS_READ, ARRAY_SIZE(&mda));
    progress_set_message(progress, _("Reading %s..."), mailbox_path(m));
  }
  maildir_delayed_parsing(m, &mda, progress);
  progress_free(&progress);
 
  maildir_move_to_mailbox(m, &mda);
  maildirarray_clear(&mda);
 
  if (!mdata->umask)
    mdata->umask = maildir_umask(m);
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

maildir_check()

static enum MxStatus maildir_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 maildir folders. The basic idea here is we check to see if either the new or cur subdirectories have changed, and if so, we scan them for the list of files. We check for newly added messages, and then merge the flags messages we already knew about. We don't treat either subdirectory differently, as mail could be copied directly into the cur directory from another agent.

Definition at line 545 of file mailbox.c.

{
  struct stat st_new = { 0 }; /* status of the "new" subdirectory */
  struct stat st_cur = { 0 }; /* status of the "cur" subdirectory */
  int changed = MMC_NO_DIRS;  /* which subdirectories have changed */
  bool occult = false;        /* messages were removed from the mailbox */
  int num_new = 0;            /* number of new messages added to the mailbox */
  bool flags_changed = false; /* message flags were changed in the mailbox */
  struct HashTable *hash_names = NULL; // Hash Table: "base-filename" -> MdEmail
  struct MaildirMboxData *mdata = maildir_mdata_get(m);
 
  const bool c_check_new = cs_subset_bool(NeoMutt->sub, "check_new");
  if (!c_check_new)
    return MX_STATUS_OK;
 
  struct Buffer *buf = buf_pool_get();
  buf_printf(buf, "%s/new", mailbox_path(m));
  if (stat(buf_string(buf), &st_new) == -1)
  {
    buf_pool_release(&buf);
    return MX_STATUS_ERROR;
  }
 
  buf_printf(buf, "%s/cur", mailbox_path(m));
  if (stat(buf_string(buf), &st_cur) == -1)
  {
    buf_pool_release(&buf);
    return MX_STATUS_ERROR;
  }
 
  /* determine which subdirectories need to be scanned */
  if (mutt_file_stat_timespec_compare(&st_new, MUTT_STAT_MTIME, &mdata->mtime) > 0)
    changed = MMC_NEW_DIR;
  if (mutt_file_stat_timespec_compare(&st_cur, MUTT_STAT_MTIME, &mdata->mtime_cur) > 0)
    changed |= MMC_CUR_DIR;
 
  if (changed == MMC_NO_DIRS)
  {
    buf_pool_release(&buf);
    return MX_STATUS_OK; /* nothing to do */
  }
 
  /* 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_cur, &st_cur, MUTT_STAT_MTIME);
    mutt_file_get_stat_timespec(&mdata->mtime, &st_new, MUTT_STAT_MTIME);
  }
 
  /* do a fast scan of just the filenames in
   * the subdirectories that have changed.  */
  struct MdEmailArray mda = ARRAY_HEAD_INITIALIZER;
  if (changed & MMC_NEW_DIR)
    maildir_parse_dir(m, &mda, "new", NULL);
  if (changed & MMC_CUR_DIR)
    maildir_parse_dir(m, &mda, "cur", NULL);
 
  /* we create a hash table keyed off the canonical (sans flags) filename
   * of each message we scanned.  This is used in the loop over the
   * existing messages below to do some correlation.  */
  hash_names = mutt_hash_new(ARRAY_SIZE(&mda), MUTT_HASH_NO_FLAGS);
 
  struct MdEmail *md = NULL;
  struct MdEmail **mdp = NULL;
  ARRAY_FOREACH(mdp, &mda)
  {
    md = *mdp;
    maildir_canon_filename(buf, md->email->path);
    md->canon_fname = buf_strdup(buf);
    mutt_hash_insert(hash_names, md->canon_fname, md);
  }
 
  /* check for modifications and adjust flags */
  for (int i = 0; i < m->msg_count; i++)
  {
    struct Email *e = m->emails[i];
    if (!e)
      break;
 
    maildir_canon_filename(buf, e->path);
    md = mutt_hash_find(hash_names, buf_string(buf));
    if (md && md->email)
    {
      /* message already exists, merge flags */
 
      /* check to see if the message has moved to a different
       * subdirectory.  If so, update the associated filename.  */
      if (!mutt_str_equal(e->path, md->email->path))
        mutt_str_replace(&e->path, md->email->path);
 
      /* if the user hasn't modified the flags on this message, update
       * the flags we just detected.  */
      if (!e->changed)
        if (maildir_update_flags(m, e, md->email))
          flags_changed = true;
 
      if (e->deleted == e->trash)
      {
        if (e->deleted != md->email->deleted)
        {
          e->deleted = md->email->deleted;
          flags_changed = true;
        }
      }
      e->trash = md->email->trash;
 
      /* this is a duplicate of an existing email, so remove it */
      email_free(&md->email);
    }
    /* This message was not in the list of messages we just scanned.
     * Check to see if we have enough information to know if the
     * message has disappeared out from underneath us.  */
    else if (((changed & MMC_NEW_DIR) && mutt_strn_equal(e->path, "new/", 4)) ||
             ((changed & MMC_CUR_DIR) && mutt_strn_equal(e->path, "cur/", 4)))
    {
      /* This message disappeared, so we need to simulate a "reopen"
       * event.  We know it disappeared because we just scanned the
       * subdirectory it used to reside in.  */
      occult = true;
      e->deleted = true;
      e->purge = true;
    }
    else
    {
      /* This message resides in a subdirectory which was not
       * modified, so we assume that it is still present and
       * unchanged.  */
    }
  }
 
  /* destroy the file name hash */
  mutt_hash_free(&hash_names);
 
  /* If we didn't just get new mail, update the tables. */
  if (occult)
    mailbox_changed(m, NT_MAILBOX_RESORT);
 
  /* do any delayed parsing we need to do. */
  maildir_delayed_parsing(m, &mda, NULL);
 
  /* Incorporate new messages */
  num_new = maildir_move_to_mailbox(m, &mda);
  maildirarray_clear(&mda);
 
  if (num_new > 0)
  {
    mailbox_changed(m, NT_MAILBOX_INVALID);
    m->changed = true;
  }
 
  buf_pool_release(&buf);
 
  ARRAY_FREE(&mda);
  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:

maildir_update_mtime()

void maildir_update_mtime

(

struct Mailbox *

m

)

Update our record of the Maildir modification time.

Parameters

m

Mailbox

Definition at line 722 of file mailbox.c.

{
  char buf[PATH_MAX] = { 0 };
  struct stat st = { 0 };
  struct MaildirMboxData *mdata = maildir_mdata_get(m);
  if (!mdata)
    return;
 
  snprintf(buf, sizeof(buf), "%s/%s", mailbox_path(m), "cur");
  if (stat(buf, &st) == 0)
    mutt_file_get_stat_timespec(&mdata->mtime_cur, &st, MUTT_STAT_MTIME);
 
  snprintf(buf, sizeof(buf), "%s/%s", mailbox_path(m), "new");
  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: