shared.h File Reference

Maildir shared functions. More...

#include <stdbool.h>
#include <stdio.h>
#include <sys/types.h>

Include dependency graph for shared.h:

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

Go to the source code of this file.

Functions
void	maildir_canon_filename (struct Buffer *dest, const char *src)
	Generate the canonical filename for a Maildir folder.
mode_t	maildir_umask (struct Mailbox *m)
	Create a umask from the mailbox directory.
bool	maildir_update_flags (struct Mailbox *m, struct Email *e_old, struct Email *e_new)
	Update the mailbox flags.
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 (const char *fname, bool is_old, struct Email *e)
	Actually parse a maildir message.
bool	maildir_parse_stream (FILE *fp, const char *fname, bool is_old, struct Email *e)
	Parse a Maildir message.
int	maildir_path_is_empty (struct Buffer *path)
	Is the mailbox empty.
int	maildir_rewrite_message (struct Mailbox *m, struct Email *e)
	Sync a message in an Maildir folder.
bool	maildir_sync_mailbox_message (struct Mailbox *m, struct Email *e, struct HeaderCache *hc)
	Save changes to the mailbox.
void	maildir_update_mtime (struct Mailbox *m)
	Update our record of the Maildir modification time.

Detailed Description

Maildir shared functions.

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 shared.h.

Function Documentation

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. Additionally, : may be replaced as the field delimiter by a user defined alternative.

Definition at line 72 of file shared.c.

{
  if (!dest || !src)
    return;
 
  char *t = strrchr(src, '/');
  if (t)
    src = t + 1;
 
  buf_strcpy(dest, src);
 
  const char c_maildir_field_delimiter = *cc_maildir_field_delimiter();
 
  char searchable_bytes[8] = { 0 };
  snprintf(searchable_bytes, sizeof(searchable_bytes), ",%c", c_maildir_field_delimiter);
  char *u = strpbrk(dest->data, searchable_bytes);
 
  if (u)
  {
    *u = '\0';
    dest->dptr = u;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

maildir_umask()

mode_t maildir_umask

(

struct Mailbox *

m

)

Create a umask from the mailbox directory.

Parameters

m

Mailbox

Return values

num

Umask

Definition at line 46 of file shared.c.

{
  struct MaildirMboxData *mdata = maildir_mdata_get(m);
  if (mdata && mdata->umask)
    return mdata->umask;
 
  struct stat st = { 0 };
  if (stat(mailbox_path(m), &st) != 0)
  {
    mutt_debug(LL_DEBUG1, "stat failed on %s\n", mailbox_path(m));
    return 077;
  }
 
  return 0777 & ~st.st_mode;
}

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 104 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:

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_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 71 of file message.c.

{
  *dest = '\0';
 
  const char *flags = NULL;
 
  struct MaildirEmailData *edata = maildir_edata_get(e);
  if (edata)
    flags = edata->custom_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 168 of file message.c.

{
  static unsigned int new_hits = 0, cur_hits = 0; /* simple dynamic optimization */
 
  struct Buffer *unique = buf_pool_get();
  maildir_canon_filename(unique, msg);
 
  /* Prevent counter saturation by halving both when either gets large */
  if ((new_hits > (UINT_MAX / 2)) || (cur_hits > (UINT_MAX / 2)))
  {
    new_hits /= 2;
    cur_hits /= 2;
  }
 
  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 > cur_hits)
      new_hits++;
    else
      cur_hits++;
 
    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 > cur_hits)
      cur_hits++;
    else
      new_hits++;
 
    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 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_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_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_path_is_empty()

int maildir_path_is_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 57 of file path.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_rewrite_message()

int maildir_rewrite_message	(	struct Mailbox *	m,
		struct Email *	e )

Sync a message in an Maildir folder.

Parameters

m	Mailbox
e	Email

Return values

0	Success
-1	Error

Definition at line 467 of file message.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)
  {
    mx_msg_close(m, &src);
    mx_msg_close(m, &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 = 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_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 315 of file message.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);
    maildir_hcache_delete(hc, e);
    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;
  }
 
  if (e->changed)
    maildir_hcache_store(hc, e);
 
  return true;
}

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: