lib.h File Reference

Maildir local mailbox type. More...

#include <stdbool.h>
#include <stdio.h>
#include "core/lib.h"

Include dependency graph for lib.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
int	maildir_check_empty (struct Buffer *path)
	Is the mailbox empty.
struct Email *	maildir_email_new (void)
	Create a Maildir Email.
void	maildir_gen_flags (char *dest, size_t destlen, struct Email *e)
	Generate the Maildir flags for an email.
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() -.
FILE *	maildir_open_find_message (const char *folder, const char *msg, char **newname)
	Find a message by name.
void	maildir_parse_flags (struct Email *e, const char *path)
	Parse Maildir file flags.
bool	maildir_parse_message (enum MailboxType type, const char *fname, bool is_old, struct Email *e)
	Actually parse a maildir message.
bool	maildir_parse_stream (enum MailboxType type, FILE *fp, const char *fname, bool is_old, struct Email *e)
	Parse a Maildir message.
bool	maildir_sync_mailbox_message (struct Mailbox *m, struct Email *e, struct HeaderCache *hc)
	Save changes to the mailbox.
bool	maildir_update_flags (struct Mailbox *m, struct Email *e_old, struct Email *e_new)
	Update the mailbox flags.
int	mh_check_empty (struct Buffer *path)
	Is mailbox empty.
int	mh_sync_mailbox_message (struct Mailbox *m, struct Email *e, struct HeaderCache *hc)
	Save changes to the mailbox.

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

Detailed Description

Maildir local mailbox type.

Authors

• 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 lib.h.

Function Documentation

maildir_check_empty()

int maildir_check_empty

(

struct Buffer *

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

{
  DIR *dir = NULL;
  struct dirent *de = NULL;
  int rc = 1; /* assume empty until we find a message */
  char realpath[PATH_MAX] = { 0 };
  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", buf_string(path),
             (iter == 0) ? "cur" : "new");
    dir = mutt_file_opendir(realpath, MUTT_OPENDIR_CREATE);
    if (!dir)
      return -1;
    while ((de = readdir(dir)))
    {
      if (*de->d_name != '.')
      {
        rc = 0;
        break;
      }
    }
    closedir(dir);
    iter++;
  } while (rc && iter < 2);
 
  return rc;
}

Here is the call graph for this function:

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 85 of file maildir.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_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 206 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] = { 0 };
    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)
      mutt_qsort_r(tmp, strlen(tmp), 1, maildir_sort_flags, NULL);
 
    const char c_maildir_field_delimiter = *cc_maildir_field_delimiter();
    snprintf(dest, destlen, "%c2,%s", c_maildir_field_delimiter, tmp);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

maildir_open_find_message()

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

Find a message by name.

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

{
  static unsigned int new_hits = 0, cur_hits = 0; /* simple dynamic optimization */
 
  struct Buffer *unique = buf_pool_get();
  maildir_canon_filename(unique, msg);
 
  FILE *fp = maildir_open_find_message_dir(folder, buf_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, buf_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:
  buf_pool_release(&unique);
 
  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 840 of file maildir.c.

{
  char *q = NULL;
 
  e->flagged = false;
  e->read = false;
  e->replied = false;
 
  struct MaildirEmailData *edata = maildir_edata_get(e);
 
  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->maildir_flags, p);
    q = edata->maildir_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->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_message()

bool 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

Return values

true

Success

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

Definition at line 954 of file maildir.c.

{
  if (!fname || !e)
    return false;
 
  FILE *fp = fopen(fname, "r");
  if (!fp)
    return false;
 
  bool rc = maildir_parse_stream(type, 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_parse_stream()

bool 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

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 912 of file maildir.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;
 
  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_sync_mailbox_message()

bool maildir_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

true	Success
false	Error

Definition at line 977 of file maildir.c.

{
  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] = { 0 };
    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);
      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, e) == -1)
      return false;
  }
 
#ifdef USE_HCACHE
  if (hc && e->changed)
  {
    const char *key = e->path + 3;
    size_t keylen = maildir_hcache_keylen(key);
    hcache_store(hc, key, keylen, e, 0);
  }
#endif
 
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

maildir_update_flags()

bool maildir_update_flags	(	struct Mailbox *	m,
		struct Email *	e_old,
		struct Email *	e_new
	)

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 120 of file shared.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_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 166 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_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 746 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_record(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(hc, key, keylen, e, 0);
  }
#endif
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function: