maildir.c File Reference

Maildir local mailbox type. More...

#include "config.h"
#include <dirent.h>
#include <errno.h>
#include <fcntl.h>
#include <inttypes.h>
#include <limits.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>
#include <utime.h>
#include "private.h"
#include "mutt/lib.h"
#include "config/lib.h"
#include "email/lib.h"
#include "core/lib.h"
#include "lib.h"
#include "progress/lib.h"
#include "copy.h"
#include "edata.h"
#include "mdata.h"
#include "mdemail.h"
#include "mutt_globals.h"
#include "mx.h"
#include "monitor.h"
#include "hcache/lib.h"
#include "notmuch/lib.h"

Include dependency graph for maildir.c:

Go to the source code of this file.

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

Functions
static void	maildir_check_dir (struct Mailbox *m, const char *dir_name, bool check_new, bool check_stats)
	Check for new mail / mail counts. More...
static int	ch_compare (const void *a, const void *b)
	qsort() callback to sort characters More...
void	maildir_gen_flags (char *dest, size_t destlen, struct Email *e)
	Generate the Maildir flags for an email. More...
int	maildir_commit_message (struct Mailbox *m, struct Message *msg, struct Email *e)
	Commit a message to a maildir folder. More...
int	maildir_rewrite_message (struct Mailbox *m, int msgno)
	Sync a message in an MH folder. More...
int	maildir_sync_message (struct Mailbox *m, int msgno)
	Sync an email to a Maildir folder. More...
void	maildir_update_mtime (struct Mailbox *m)
	Update our record of the Maildir modification time. More...
static int	maildir_cmp_inode (const void *a, const void *b)
	Compare two Maildirs by inode number - Implements sort_t -. More...
int	maildir_parse_dir (struct Mailbox *m, struct MdEmailArray *mda, const char *subdir, struct Progress *progress)
	Read a Maildir mailbox. More...
size_t	maildir_hcache_keylen (const char *fn)
	Calculate the length of the Maildir path. More...
void	maildir_delayed_parsing (struct Mailbox *m, struct MdEmailArray *mda, struct Progress *progress)
	This function does the second parsing pass. More...
int	maildir_read_dir (struct Mailbox *m, const char *subdir)
	Read a Maildir style mailbox. More...
void	maildir_canon_filename (struct Buffer *dest, const char *src)
	Generate the canonical filename for a Maildir folder. More...
static FILE *	maildir_open_find_message_dir (const char *folder, const char *unique, const char *subfolder, char **newname)
	Find a message in a maildir folder. More...
void	maildir_parse_flags (struct Email *e, const char *path)
	Parse Maildir file flags. More...
struct Email *	maildir_parse_stream (enum MailboxType type, FILE *fp, const char *fname, bool is_old, struct Email *e)
	Parse a Maildir message. More...
struct Email *	maildir_parse_message (enum MailboxType type, const char *fname, bool is_old, struct Email *e)
	Actually parse a maildir message. More...
bool	maildir_sync_mailbox_message (struct Mailbox *m, int msgno, struct HeaderCache *hc)
	Save changes to the mailbox. More...
FILE *	maildir_open_find_message (const char *folder, const char *msg, char **newname)
	Find a new. More...
int	maildir_check_empty (const char *path)
	Is the mailbox empty. More...
bool	maildir_ac_owns_path (struct Account *a, const char *path)
	Check whether an Account own a Mailbox path - Implements MxOps::ac_owns_path() -. More...
bool	maildir_ac_add (struct Account *a, struct Mailbox *m)
	Add a Mailbox to an Account - Implements MxOps::ac_add() -. More...
static enum MxOpenReturns	maildir_mbox_open (struct Mailbox *m)
	Open a Mailbox - Implements MxOps::mbox_open() -. More...
static bool	maildir_mbox_open_append (struct Mailbox *m, OpenMailboxFlags flags)
	Open a Mailbox for appending - Implements MxOps::mbox_open_append() -. More...
enum MxStatus	maildir_mbox_check (struct Mailbox *m)
	Check for new mail - Implements MxOps::mbox_check() -. More...
static enum MxStatus	maildir_mbox_check_stats (struct Mailbox *m, uint8_t flags)
	Check the Mailbox statistics - Implements MxOps::mbox_check_stats() -. More...
enum MxStatus	maildir_mbox_sync (struct Mailbox *m)
	Save changes to the Mailbox - Implements MxOps::mbox_sync() -. More...
enum MxStatus	maildir_mbox_close (struct Mailbox *m)
	Close a Mailbox - Implements MxOps::mbox_close() -. More...
static bool	maildir_msg_open (struct Mailbox *m, struct Message *msg, int msgno)
	Open an email message in a Mailbox - Implements MxOps::msg_open() -. More...
bool	maildir_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() -. More...
static int	maildir_msg_commit (struct Mailbox *m, struct Message *msg)
	Save changes to an email - Implements MxOps::msg_commit() -. More...
int	maildir_msg_close (struct Mailbox *m, struct Message *msg)
	Close an email - Implements MxOps::msg_close() -. More...
static int	maildir_msg_save_hcache (struct Mailbox *m, struct Email *e)
	Save message to the header cache - Implements MxOps::msg_save_hcache() -. More...
int	maildir_path_canon (char *buf, size_t buflen)
	Canonicalise a Mailbox path - Implements MxOps::path_canon() -. More...
int	maildir_path_parent (char *buf, size_t buflen)
	Find the parent of a Mailbox path - Implements MxOps::path_parent() -. More...
int	maildir_path_pretty (char *buf, size_t buflen, const char *folder)
	Abbreviate a Mailbox path - Implements MxOps::path_pretty() -. More...
static enum MailboxType	maildir_path_probe (const char *path, const struct stat *st)
	Is this a Maildir Mailbox? - Implements MxOps::path_probe() -. More...

Variables
struct MxOps	MxMaildirOps
	Maildir Mailbox - Implements MxOps -. More...

Detailed Description

Maildir local mailbox type.

Authors

• Michael R. Elkins
• Thomas Roessler
• Michael R. Elkins
• Richard Russon

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

Macro Definition Documentation

MMC_NO_DIRS

#define MMC_NO_DIRS   0

No directories changed.

Definition at line 73 of file maildir.c.

MMC_NEW_DIR

#define MMC_NEW_DIR   (1 << 0)

'new' directory changed

Definition at line 74 of file maildir.c.

MMC_CUR_DIR

#define MMC_CUR_DIR   (1 << 1)

'cur' directory changed

Definition at line 75 of file maildir.c.

Function Documentation

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 86 of file maildir.c.

{
  DIR *dirp = NULL;
  struct dirent *de = NULL;
  char *p = NULL;
  struct stat st = { 0 };
 
  struct Buffer *path = mutt_buffer_pool_get();
  struct Buffer *msgpath = mutt_buffer_pool_get();
  mutt_buffer_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 m, 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(mutt_buffer_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;
 
  dirp = opendir(mutt_buffer_string(path));
  if (!dirp)
  {
    m->type = MUTT_UNKNOWN;
    goto cleanup;
  }
 
  while ((de = readdir(dirp)))
  {
    if (*de->d_name == '.')
      continue;
 
    p = strstr(de->d_name, ":2,");
    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)
        {
          mutt_buffer_printf(msgpath, "%s/%s", mutt_buffer_string(path), de->d_name);
          /* ensure this message was received since leaving this m */
          if ((stat(mutt_buffer_string(msgpath), &st) == 0) &&
              (mutt_file_stat_timespec_compare(&st, MUTT_STAT_CTIME, &m->last_visited) <= 0))
          {
            continue;
          }
        }
        m->has_new = true;
        check_new = false;
        m->msg_new++;
        if (!check_stats)
          break;
      }
    }
  }
 
  closedir(dirp);
 
cleanup:
  mutt_buffer_pool_release(&path);
  mutt_buffer_pool_release(&msgpath);
}

Here is the call graph for this function:

ch_compare()

static int ch_compare ( const void *  a, const void *  b  )

static

qsort() callback to sort characters

Parameters

a	First character to compare
b	Second character to compare

Return values

-1	a precedes b
0	a and b are identical
1	b precedes a

Definition at line 175 of file maildir.c.

{
  return (int) (*((const char *) a) - *((const char *) b));
}

Here is the caller graph for this function:

maildir_gen_flags()

void maildir_gen_flags	(	char *	dest,
		size_t	destlen,
		struct Email *	e
	)

Generate the Maildir flags for an email.

Parameters

dest	Buffer for the result
destlen	Length of buffer
e	Email

Definition at line 186 of file maildir.c.

{
  *dest = '\0';
 
  const char *flags = NULL;
 
  struct MaildirEmailData *edata = maildir_edata_get(e);
  if (edata)
    flags = edata->maildir_flags;
 
  /* The maildir specification requires that all files in the cur
   * subdirectory have the :unique string appended, regardless of whether
   * or not there are any flags.  If .old is set, we know that this message
   * will end up in the cur directory, so we include it in the following
   * test even though there is no associated flag.  */
 
  if (e->flagged || e->replied || e->read || e->deleted || e->old || flags)
  {
    char tmp[1024];
    snprintf(tmp, sizeof(tmp), "%s%s%s%s%s", e->flagged ? "F" : "", e->replied ? "R" : "",
             e->read ? "S" : "", e->deleted ? "T" : "", NONULL(flags));
    if (flags)
      qsort(tmp, strlen(tmp), 1, ch_compare);
    snprintf(dest, destlen, ":2,%s", tmp);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

maildir_commit_message()

int maildir_commit_message	(	struct Mailbox *	m,
		struct Message *	msg,
		struct Email *	e
	)

Commit a message to a maildir folder.

Parameters

m	Mailbox
msg	Message to commit
e	Email

Return values

0	Success
-1	Failure

msg->path contains the file name of a file in tmp/. We take the flags from this file's name.

m is the mail folder we commit to.

e is a header structure to which we write the message's new file name. This is used in the mh and maildir folder sync routines. When this routine is invoked from mx_msg_commit(), e is NULL.

msg->path looks like this:

tmp/{cur,new}.neomutt-HOSTNAME-PID-COUNTER:flags

See also maildir_msg_open_new().

Definition at line 237 of file maildir.c.

{
  char subdir[4];
  char suffix[16];
  int rc = 0;
 
  if (mutt_file_fsync_close(&msg->fp))
  {
    mutt_perror(_("Could not flush message to disk"));
    return -1;
  }
 
  /* extract the subdir */
  char *s = strrchr(msg->path, '/') + 1;
  mutt_str_copy(subdir, s, 4);
 
  /* extract the flags */
  s = strchr(s, ':');
  if (s)
    mutt_str_copy(suffix, s, sizeof(suffix));
  else
    suffix[0] = '\0';
 
  /* construct a new file name. */
  struct Buffer *path = mutt_buffer_pool_get();
  struct Buffer *full = mutt_buffer_pool_get();
  while (true)
  {
    mutt_buffer_printf(path, "%s/%lld.R%" PRIu64 ".%s%s", subdir,
                       (long long) mutt_date_epoch(), mutt_rand64(),
                       NONULL(ShortHostname), suffix);
    mutt_buffer_printf(full, "%s/%s", mailbox_path(m), mutt_buffer_string(path));
 
    mutt_debug(LL_DEBUG2, "renaming %s to %s\n", msg->path, mutt_buffer_string(full));
 
    if (mutt_file_safe_rename(msg->path, mutt_buffer_string(full)) == 0)
    {
      /* Adjust the mtime on the file to match the time at which this
       * message was received.  Currently this is only set when copying
       * messages between mailboxes, so we test to ensure that it is
       * actually set.  */
      if (msg->received != 0)
      {
        struct utimbuf ut;
        int rc_utime;
 
        ut.actime = msg->received;
        ut.modtime = msg->received;
        do
        {
          rc_utime = utime(mutt_buffer_string(full), &ut);
        } while ((rc_utime == -1) && (errno == EINTR));
        if (rc_utime == -1)
        {
          mutt_perror(_("maildir_commit_message(): unable to set time on file"));
          rc = -1;
          goto cleanup;
        }
      }
 
#ifdef USE_NOTMUCH
      if (m->type == MUTT_NOTMUCH)
        nm_update_filename(m, e->path, mutt_buffer_string(full), e);
#endif
      if (e)
        mutt_str_replace(&e->path, mutt_buffer_string(path));
      mutt_str_replace(&msg->committed_path, mutt_buffer_string(full));
      FREE(&msg->path);
 
      goto cleanup;
    }
    else if (errno != EEXIST)
    {
      mutt_perror(mailbox_path(m));
      rc = -1;
      goto cleanup;
    }
  }
 
cleanup:
  mutt_buffer_pool_release(&path);
  mutt_buffer_pool_release(&full);
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

maildir_rewrite_message()

int maildir_rewrite_message	(	struct Mailbox *	m,
		int	msgno
	)

Sync a message in an MH folder.

Parameters

m	Mailbox
msgno	Index number

Return values

0	Success
-1	Error

Definition at line 330 of file maildir.c.

{
  if (!m || !m->emails || (msgno >= m->msg_count))
    return -1;
 
  struct Email *e = m->emails[msgno];
  if (!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, msgno);
  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];
    char partpath[PATH_MAX];
    snprintf(oldpath, sizeof(oldpath), "%s/%s", mailbox_path(m), e->path);
    mutt_str_copy(partpath, e->path, sizeof(partpath));
 
    rc = maildir_commit_message(m, dest, e);
 
    if (rc == 0)
    {
      unlink(oldpath);
      restore = false;
    }
  }
  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:

maildir_sync_message()

int maildir_sync_message	(	struct Mailbox *	m,
		int	msgno
	)

Sync an email to a Maildir folder.

Parameters

m	Mailbox
msgno	Index number

Return values

0	Success
-1	Error

Definition at line 387 of file maildir.c.

{
  if (!m || !m->emails || (msgno >= m->msg_count))
    return -1;
 
  struct Email *e = m->emails[msgno];
  if (!e)
    return -1;
 
  struct Buffer *newpath = NULL;
  struct Buffer *partpath = NULL;
  struct Buffer *fullpath = NULL;
  struct Buffer *oldpath = NULL;
  char suffix[16];
  int rc = 0;
 
  /* TODO: why the e->env check? */
  if (e->attach_del || (e->env && e->env->changed))
  {
    /* when doing attachment deletion/rethreading, fall back to the MH case. */
    if (maildir_rewrite_message(m, msgno) != 0)
      return -1;
    /* TODO: why the env check? */
    if (e->env)
      e->env->changed = 0;
  }
  else
  {
    /* we just have to rename the file. */
 
    char *p = strrchr(e->path, '/');
    if (!p)
    {
      mutt_debug(LL_DEBUG1, "%s: unable to find subdir!\n", e->path);
      return -1;
    }
    p++;
    newpath = mutt_buffer_pool_get();
    partpath = mutt_buffer_pool_get();
    fullpath = mutt_buffer_pool_get();
    oldpath = mutt_buffer_pool_get();
 
    mutt_buffer_strcpy(newpath, p);
 
    /* kill the previous flags */
    p = strchr(newpath->data, ':');
    if (p)
    {
      *p = '\0';
      newpath->dptr = p; /* fix buffer up, just to be safe */
    }
 
    maildir_gen_flags(suffix, sizeof(suffix), e);
 
    mutt_buffer_printf(partpath, "%s/%s%s", (e->read || e->old) ? "cur" : "new",
                       mutt_buffer_string(newpath), suffix);
    mutt_buffer_printf(fullpath, "%s/%s", mailbox_path(m), mutt_buffer_string(partpath));
    mutt_buffer_printf(oldpath, "%s/%s", mailbox_path(m), e->path);
 
    if (mutt_str_equal(mutt_buffer_string(fullpath), mutt_buffer_string(oldpath)))
    {
      /* message hasn't really changed */
      goto cleanup;
    }
 
    /* record that the message is possibly marked as trashed on disk */
    e->trash = e->deleted;
 
    if (rename(mutt_buffer_string(oldpath), mutt_buffer_string(fullpath)) != 0)
    {
      mutt_perror("rename");
      rc = -1;
      goto cleanup;
    }
    mutt_str_replace(&e->path, mutt_buffer_string(partpath));
  }
 
cleanup:
  mutt_buffer_pool_release(&newpath);
  mutt_buffer_pool_release(&partpath);
  mutt_buffer_pool_release(&fullpath);
  mutt_buffer_pool_release(&oldpath);
 
  return rc;
}

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 477 of file maildir.c.

{
  char buf[PATH_MAX];
  struct stat st = { 0 };
  struct MaildirMboxData *mdata = maildir_mdata_get(m);
 
  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(&m->mtime, &st, MUTT_STAT_MTIME);
}

Here is the call graph for this function:

maildir_parse_dir()

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

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 513 of file maildir.c.

{
  struct dirent *de = NULL;
  int rc = 0;
  bool is_old = false;
  struct MdEmail *entry = NULL;
  struct Email *e = NULL;
 
  struct Buffer *buf = mutt_buffer_pool_get();
 
  mutt_buffer_printf(buf, "%s/%s", mailbox_path(m), subdir);
  const bool c_mark_old = cs_subset_bool(NeoMutt->sub, "mark_old");
  is_old = c_mark_old ? mutt_str_equal("cur", subdir) : false;
 
  DIR *dirp = opendir(mutt_buffer_string(buf));
  if (!dirp)
  {
    rc = -1;
    goto cleanup;
  }
 
  while (((de = readdir(dirp))) && !SigInt)
  {
    if (*de->d_name == '.')
      continue;
 
    /* FOO - really ignore the return value? */
    mutt_debug(LL_DEBUG2, "queueing %s\n", de->d_name);
 
    e = email_new();
    e->edata = maildir_edata_new();
    e->edata_free = maildir_edata_free;
 
    e->old = is_old;
    maildir_parse_flags(e, de->d_name);
 
    if (m->verbose && progress)
      progress_update(progress, ARRAY_SIZE(mda) + 1, -1);
 
    mutt_buffer_printf(buf, "%s/%s", subdir, de->d_name);
    e->path = mutt_buffer_strdup(buf);
 
    entry = maildir_entry_new();
    entry->email = e;
    entry->inode = de->d_ino;
    ARRAY_ADD(mda, entry);
  }
 
  closedir(dirp);
 
  if (SigInt)
  {
    SigInt = false;
    return -2; /* action aborted */
  }
 
  ARRAY_SORT(mda, maildir_cmp_inode);
 
cleanup:
  mutt_buffer_pool_release(&buf);
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

maildir_hcache_keylen()

size_t maildir_hcache_keylen

(

const char *

fn

)

Calculate the length of the Maildir path.

Parameters

fn

File name

Return values

num	Length in bytes

Note

This length excludes the flags, which will vary

Definition at line 585 of file maildir.c.

{
  const char *p = strrchr(fn, ':');
  return p ? (size_t) (p - fn) : mutt_str_len(fn);
}

Here is the call graph for this function:

Here is the caller graph for this function:

maildir_delayed_parsing()

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

This function does the second parsing pass.

Parameters

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

Definition at line 597 of file maildir.c.

{
  char fn[PATH_MAX];
 
#ifdef USE_HCACHE
  const char *const c_header_cache = cs_subset_path(NeoMutt->sub, "header_cache");
  struct HeaderCache *hc = mutt_hcache_open(c_header_cache, mailbox_path(m), NULL);
#endif
 
  struct MdEmail *md = NULL;
  struct MdEmail **mdp = NULL;
  ARRAY_FOREACH(mdp, mda)
  {
    md = *mdp;
    if (!md || !md->email || md->header_parsed)
      continue;
 
    if (m->verbose && progress)
      progress_update(progress, ARRAY_FOREACH_IDX, -1);
 
    snprintf(fn, sizeof(fn), "%s/%s", mailbox_path(m), md->email->path);
 
#ifdef USE_HCACHE
    struct stat st_lastchanged = { 0 };
    int rc = 0;
    const bool c_maildir_header_cache_verify = cs_subset_bool(NeoMutt->sub, "maildir_header_cache_verify");
    if (c_maildir_header_cache_verify)
    {
      rc = stat(fn, &st_lastchanged);
    }
 
    const char *key = md->email->path + 3;
    size_t keylen = maildir_hcache_keylen(key);
    struct HCacheEntry hce = mutt_hcache_fetch(hc, key, keylen, 0);
 
    if (hce.email && (rc == 0) && (st_lastchanged.st_mtime <= hce.uidvalidity))
    {
      hce.email->edata = maildir_edata_new();
      hce.email->edata_free = maildir_edata_free;
      hce.email->old = md->email->old;
      hce.email->path = mutt_str_dup(md->email->path);
      email_free(&md->email);
      md->email = hce.email;
      maildir_parse_flags(md->email, fn);
    }
    else
#endif
    {
      if (maildir_parse_message(m->type, fn, md->email->old, md->email))
      {
        md->header_parsed = true;
#ifdef USE_HCACHE
        key = md->email->path + 3;
        keylen = maildir_hcache_keylen(key);
        mutt_hcache_store(hc, key, keylen, md->email, 0);
#endif
      }
      else
        email_free(&md->email);
    }
  }
#ifdef USE_HCACHE
  mutt_hcache_close(hc);
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

maildir_read_dir()

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

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 671 of file maildir.c.

{
  if (!m)
    return -1;
 
  struct Progress *progress = NULL;
 
  if (m->verbose)
  {
    char msg[PATH_MAX];
    snprintf(msg, sizeof(msg), _("Scanning %s..."), mailbox_path(m));
    progress = progress_new(msg, MUTT_PROGRESS_READ, 0);
  }
 
  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)
  {
    char msg[PATH_MAX];
    snprintf(msg, sizeof(msg), _("Reading %s..."), mailbox_path(m));
    progress = progress_new(msg, MUTT_PROGRESS_READ, ARRAY_SIZE(&mda));
  }
  maildir_delayed_parsing(m, &mda, progress);
  progress_free(&progress);
 
  maildir_move_to_mailbox(m, &mda);
 
  if (!mdata->mh_umask)
    mdata->mh_umask = mh_umask(m);
 
  return 0;
}

Here is the call graph for this function:

maildir_canon_filename()

void maildir_canon_filename	(	struct Buffer *	dest,
		const char *	src
	)

Generate the canonical filename for a Maildir folder.

Parameters

dest	Buffer for the result
src	Buffer containing source filename

Note

maildir filename is defined as: <base filename>:2,<flags> but <base filename> may contain additional comma separated fields.

Definition at line 725 of file maildir.c.

{
  if (!dest || !src)
    return;
 
  char *t = strrchr(src, '/');
  if (t)
    src = t + 1;
 
  mutt_buffer_strcpy(dest, src);
  char *u = strpbrk(dest->data, ",:");
  if (u)
  {
    *u = '\0';
    dest->dptr = u;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

maildir_open_find_message_dir()

static FILE* maildir_open_find_message_dir ( const char *  folder, const char *  unique, const char *  subfolder, char **  newname  )

static

Find a message in a maildir folder.

Parameters

[in]	folder	Base folder
[in]	unique	Unique part of filename
[in]	subfolder	Subfolder to search, e.g. 'cur'
[out]	newname	File's new name

Return values

ptr	File handle

These functions try to find a message in a maildir folder when it has moved under our feet. Note that this code is rather expensive, but then again, it's called rarely.

Definition at line 755 of file maildir.c.

{
  struct Buffer *dir = mutt_buffer_pool_get();
  struct Buffer *tunique = mutt_buffer_pool_get();
  struct Buffer *fname = mutt_buffer_pool_get();
 
  struct dirent *de = NULL;
 
  FILE *fp = NULL;
  int oe = ENOENT;
 
  mutt_buffer_printf(dir, "%s/%s", folder, subfolder);
 
  DIR *dp = opendir(mutt_buffer_string(dir));
  if (!dp)
  {
    errno = ENOENT;
    goto cleanup;
  }
 
  while ((de = readdir(dp)))
  {
    maildir_canon_filename(tunique, de->d_name);
 
    if (mutt_str_equal(mutt_buffer_string(tunique), unique))
    {
      mutt_buffer_printf(fname, "%s/%s/%s", folder, subfolder, de->d_name);
      fp = fopen(mutt_buffer_string(fname), "r");
      oe = errno;
      break;
    }
  }
 
  closedir(dp);
 
  if (newname && fp)
    *newname = mutt_buffer_strdup(fname);
 
  errno = oe;
 
cleanup:
  mutt_buffer_pool_release(&dir);
  mutt_buffer_pool_release(&tunique);
  mutt_buffer_pool_release(&fname);
 
  return fp;
}

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 809 of file maildir.c.

{
  char *q = NULL;
 
  e->flagged = false;
  e->read = false;
  e->replied = false;
 
  struct MaildirEmailData *edata = maildir_edata_get(e);
 
  char *p = strrchr(path, ':');
  if (p && mutt_str_startswith(p + 1, "2,"))
  {
    p += 3;
 
    mutt_str_replace(&edata->maildir_flags, p);
    q = edata->maildir_flags;
 
    while (*p)
    {
      switch (*p)
      {
        case 'F':
          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->maildir_flags)
    FREE(&edata->maildir_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()

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

Parse a Maildir message.

Parameters

type	Mailbox type, e.g. MUTT_MAILDIR
fp	Message file handle
fname	Message filename
is_old	true, if the email is old (read)
e	Email

Return values

ptr	Populated Email
NULL	on error

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 881 of file maildir.c.

{
  const long size = mutt_file_get_size_fp(fp);
  if (size == 0)
  {
    return NULL;
  }
 
  if (!e)
  {
    e = email_new();
    e->edata = maildir_edata_new();
    e->edata_free = maildir_edata_free;
  }
  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;
 
  if (type == MUTT_MAILDIR)
  {
    /* 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 e;
}

Here is the call graph for this function:

Here is the caller graph for this function:

maildir_parse_message()

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

Actually parse a maildir message.

Parameters

type	Mailbox type, e.g. MUTT_MAILDIR
fname	Message filename
is_old	true, if the email is old (read)
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 maildir parsing.

Definition at line 928 of file maildir.c.

{
  FILE *fp = fopen(fname, "r");
  if (!fp)
    return NULL;
 
  struct Email *e_res = maildir_parse_stream(type, fp, fname, is_old, e);
  mutt_file_fclose(&fp);
  return e_res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

maildir_sync_mailbox_message()

bool maildir_sync_mailbox_message	(	struct Mailbox *	m,
		int	msgno,
		struct HeaderCache *	hc
	)

Save changes to the mailbox.

Parameters

m	Mailbox
msgno	Index number
hc	Header cache handle

Return values

true	Success
false	Error

Definition at line 948 of file maildir.c.

{
  struct Email *e = m->emails[msgno];
  if (!e)
    return false;
 
  const bool c_maildir_trash = cs_subset_bool(NeoMutt->sub, "maildir_trash");
  if (e->deleted && !c_maildir_trash)
  {
    char path[PATH_MAX];
    snprintf(path, sizeof(path), "%s/%s", mailbox_path(m), e->path);
#ifdef USE_HCACHE
    if (hc)
    {
      const char *key = e->path + 3;
      size_t keylen = maildir_hcache_keylen(key);
      mutt_hcache_delete_record(hc, key, keylen);
    }
#endif
    unlink(path);
  }
  else if (e->changed || e->attach_del ||
           ((c_maildir_trash || e->trash) && (e->deleted != e->trash)))
  {
    if (maildir_sync_message(m, msgno) == -1)
      return false;
  }
 
#ifdef USE_HCACHE
  if (hc && e->changed)
  {
    const char *key = e->path + 3;
    size_t keylen = maildir_hcache_keylen(key);
    mutt_hcache_store(hc, key, keylen, e, 0);
  }
#endif
 
  return true;
}

Here is the call graph for this function:

maildir_open_find_message()

FILE* maildir_open_find_message	(	const char *	folder,
		const char *	msg,
		char **	newname
	)

Find a new.

Parameters

[in]	folder	Maildir path
[in]	msg	Email path
[out]	newname	New name, if it has moved

Return values

ptr	File handle

Definition at line 995 of file maildir.c.

{
  static unsigned int new_hits = 0, cur_hits = 0; /* simple dynamic optimization */
 
  struct Buffer *unique = mutt_buffer_pool_get();
  maildir_canon_filename(unique, msg);
 
  FILE *fp = maildir_open_find_message_dir(folder, mutt_buffer_string(unique),
                                           (new_hits > cur_hits) ? "new" : "cur", newname);
  if (fp || (errno != ENOENT))
  {
    if ((new_hits < UINT_MAX) && (cur_hits < UINT_MAX))
    {
      new_hits += ((new_hits > cur_hits) ? 1 : 0);
      cur_hits += ((new_hits > cur_hits) ? 0 : 1);
    }
 
    goto cleanup;
  }
  fp = maildir_open_find_message_dir(folder, mutt_buffer_string(unique),
                                     (new_hits > cur_hits) ? "cur" : "new", newname);
  if (fp || (errno != ENOENT))
  {
    if ((new_hits < UINT_MAX) && (cur_hits < UINT_MAX))
    {
      new_hits += ((new_hits > cur_hits) ? 0 : 1);
      cur_hits += ((new_hits > cur_hits) ? 1 : 0);
    }
 
    goto cleanup;
  }
 
  fp = NULL;
 
cleanup:
  mutt_buffer_pool_release(&unique);
 
  return fp;
}

Here is the call graph for this function:

Here is the caller graph for this function:

maildir_check_empty()

int maildir_check_empty

(

const char *

path

)

Is the mailbox empty.

Parameters

path	Mailbox to check

Return values

1	Mailbox is empty
0	Mailbox contains mail
-1	Error

Definition at line 1042 of file maildir.c.

{
  DIR *dp = NULL;
  struct dirent *de = NULL;
  int rc = 1; /* assume empty until we find a message */
  char realpath[PATH_MAX];
  int iter = 0;
 
  /* Strategy here is to look for any file not beginning with a period */
 
  do
  {
    /* we do "cur" on the first iteration since it's more likely that we'll
     * find old messages without having to scan both subdirs */
    snprintf(realpath, sizeof(realpath), "%s/%s", path, (iter == 0) ? "cur" : "new");
    dp = opendir(realpath);
    if (!dp)
      return -1;
    while ((de = readdir(dp)))
    {
      if (*de->d_name != '.')
      {
        rc = 0;
        break;
      }
    }
    closedir(dp);
    iter++;
  } while (rc && iter < 2);
 
  return rc;
}