mbox.c File Reference

Mbox local mailbox type. More...

#include "config.h"
#include <errno.h>
#include <fcntl.h>
#include <inttypes.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <time.h>
#include <unistd.h>
#include <utime.h>
#include "mutt/lib.h"
#include "address/lib.h"
#include "config/lib.h"
#include "email/lib.h"
#include "core/lib.h"
#include "mutt.h"
#include "lib.h"
#include "progress/lib.h"
#include "copy.h"
#include "globals.h"
#include "mutt_header.h"
#include "muttlib.h"
#include "mx.h"
#include "protos.h"
#include "sort.h"

Include dependency graph for mbox.c:

Go to the source code of this file.

Data Structures
struct	MUpdate
	Store of new offsets, used by mutt_sync_mailbox() More...

Functions
static void	mbox_adata_free (void **ptr)
	Free the private Account data - Implements Account::adata_free() -.
static struct MboxAccountData *	mbox_adata_new (void)
	Create a new MboxAccountData struct.
static int	init_mailbox (struct Mailbox *m)
	Add Mbox data to the Mailbox.
static struct MboxAccountData *	mbox_adata_get (struct Mailbox *m)
	Get the private data associated with a Mailbox.
static int	mbox_lock_mailbox (struct Mailbox *m, bool excl, bool retry)
	Lock a mailbox.
static void	mbox_unlock_mailbox (struct Mailbox *m)
	Unlock a mailbox.
static enum MxOpenReturns	mmdf_parse_mailbox (struct Mailbox *m)
	Read a mailbox in MMDF format.
static enum MxOpenReturns	mbox_parse_mailbox (struct Mailbox *m)
	Read a mailbox from disk.
static int	reopen_mailbox (struct Mailbox *m)
	Close and reopen a mailbox.
static bool	mbox_has_new (struct Mailbox *m)
	Does the mailbox have new mail.
void	mbox_reset_atime (struct Mailbox *m, struct stat *st)
	Reset the access time on the mailbox file.
static bool	mbox_ac_owns_path (struct Account *a, const char *path)
	Check whether an Account owns a Mailbox path - Implements MxOps::ac_owns_path() -.
static bool	mbox_ac_add (struct Account *a, struct Mailbox *m)
	Add a Mailbox to an Account - Implements MxOps::ac_add() -.
static FILE *	mbox_open_readwrite (struct Mailbox *m)
	Open an mbox read-write.
static FILE *	mbox_open_readonly (struct Mailbox *m)
	Open an mbox read-only.
static enum MxOpenReturns	mbox_mbox_open (struct Mailbox *m)
	Open a Mailbox - Implements MxOps::mbox_open() -.
static bool	mbox_mbox_open_append (struct Mailbox *m, OpenMailboxFlags flags)
	Open a Mailbox for appending - Implements MxOps::mbox_open_append() -.
static enum MxStatus	mbox_mbox_check (struct Mailbox *m)
	Check for new mail - Implements MxOps::mbox_check() -.
static enum MxStatus	mbox_mbox_sync (struct Mailbox *m)
	Save changes to the Mailbox - Implements MxOps::mbox_sync() -.
static enum MxStatus	mbox_mbox_close (struct Mailbox *m)
	Close a Mailbox - Implements MxOps::mbox_close() -.
static bool	mbox_msg_open (struct Mailbox *m, struct Message *msg, struct Email *e)
	Open an email message in a Mailbox - Implements MxOps::msg_open() -.
static bool	mbox_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	mbox_msg_commit (struct Mailbox *m, struct Message *msg)
	Save changes to an email - Implements MxOps::msg_commit() -.
static int	mbox_msg_close (struct Mailbox *m, struct Message *msg)
	Close an email - Implements MxOps::msg_close() -.
static int	mbox_msg_padding_size (struct Mailbox *m)
	Bytes of padding between messages - Implements MxOps::msg_padding_size() -.
enum MailboxType	mbox_path_probe (const char *path, const struct stat *st)
	Is this an mbox Mailbox? - Implements MxOps::path_probe() -.
static int	mbox_path_canon (struct Buffer *path)
	Canonicalise a Mailbox path - Implements MxOps::path_canon() -.
static int	mbox_path_is_empty (struct Buffer *path)
	Is the mailbox empty - Implements MxOps::path_is_empty() -.
static int	mmdf_msg_commit (struct Mailbox *m, struct Message *msg)
	Save changes to an email - Implements MxOps::msg_commit() -.
static int	mmdf_msg_padding_size (struct Mailbox *m)
	Bytes of padding between messages - Implements MxOps::msg_padding_size() -.
static enum MxStatus	mbox_mbox_check_stats (struct Mailbox *m, uint8_t flags)
	Check the Mailbox statistics - Implements MxOps::mbox_check_stats() -.

Variables
const struct MxOps	MxMboxOps
	Mbox Mailbox - Implements MxOps -.
const struct MxOps	MxMmdfOps
	MMDF Mailbox - Implements MxOps -.

Detailed Description

Mbox local mailbox type.

Authors

• Richard Russon
• Austin Ray
• Ian Zimmerman
• 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 mbox.c.

Function Documentation

mbox_adata_new()

static struct MboxAccountData * mbox_adata_new ( void  )

static

Create a new MboxAccountData struct.

Return values

ptr	New MboxAccountData

Definition at line 95 of file mbox.c.

{
  return mutt_mem_calloc(1, sizeof(struct MboxAccountData));
}

Here is the call graph for this function:

Here is the caller graph for this function:

init_mailbox()

static int init_mailbox ( struct Mailbox *  m )

static

Add Mbox data to the Mailbox.

Parameters

m

Mailbox

Return values

0	Success
-1	Error Bad format

Definition at line 106 of file mbox.c.

{
  if (!m || !m->account)
    return -1;
  if ((m->type != MUTT_MBOX) && (m->type != MUTT_MMDF))
    return -1;
  if (m->account->adata)
    return 0;
 
  m->account->adata = mbox_adata_new();
  m->account->adata_free = mbox_adata_free;
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mbox_adata_get()

static struct MboxAccountData * mbox_adata_get ( struct Mailbox *  m )

static

Get the private data associated with a Mailbox.

Parameters

m

Mailbox

Return values

ptr	Private data

Definition at line 125 of file mbox.c.

{
  if (init_mailbox(m) == -1)
    return NULL;
  return m->account->adata;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mbox_lock_mailbox()

static int mbox_lock_mailbox ( struct Mailbox *  m, bool  excl, bool  retry  )

static

Lock a mailbox.

Parameters

m	Mailbox to lock
excl	Exclusive lock?
retry	Should retry if unable to lock?

Return values

0	Success
-1	Failure

Definition at line 140 of file mbox.c.

{
  struct MboxAccountData *adata = mbox_adata_get(m);
  if (!adata)
    return -1;
 
  int rc = mutt_file_lock(fileno(adata->fp), excl, retry);
  if (rc == 0)
  {
    adata->locked = true;
  }
  else if (retry && !excl)
  {
    m->readonly = true;
    return 0;
  }
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mbox_unlock_mailbox()

static void mbox_unlock_mailbox ( struct Mailbox *  m )

static

Unlock a mailbox.

Parameters

m	Mailbox to unlock

Definition at line 164 of file mbox.c.

{
  struct MboxAccountData *adata = mbox_adata_get(m);
  if (!adata)
    return;
 
  if (adata->locked)
  {
    fflush(adata->fp);
 
    mutt_file_unlock(fileno(adata->fp));
    adata->locked = false;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mmdf_parse_mailbox()

static enum MxOpenReturns mmdf_parse_mailbox ( struct Mailbox *  m )

static

Read a mailbox in MMDF format.

Parameters

m

Mailbox

Return values

enum	MxOpenReturns

Definition at line 184 of file mbox.c.

{
  if (!m)
    return MX_OPEN_ERROR;
 
  struct MboxAccountData *adata = mbox_adata_get(m);
  if (!adata)
    return MX_OPEN_ERROR;
 
  char buf[8192] = { 0 };
  char return_path[1024] = { 0 };
  int count = 0;
  int lines;
  time_t t = 0;
  LOFF_T loc, tmploc;
  struct Email *e = NULL;
  struct stat st = { 0 };
  struct Progress *progress = NULL;
  enum MxOpenReturns rc = MX_OPEN_ERROR;
 
  if (stat(mailbox_path(m), &st) == -1)
  {
    mutt_perror("%s", mailbox_path(m));
    goto fail;
  }
  mutt_file_get_stat_timespec(&adata->atime, &st, MUTT_STAT_ATIME);
  mutt_file_get_stat_timespec(&adata->mtime, &st, MUTT_STAT_MTIME);
  m->size = st.st_size;
 
  buf[sizeof(buf) - 1] = '\0';
 
  if (m->verbose)
  {
    progress = progress_new(MUTT_PROGRESS_READ, 0);
    progress_set_message(progress, _("Reading %s..."), mailbox_path(m));
  }
 
  while (true)
  {
    if (!fgets(buf, sizeof(buf) - 1, adata->fp))
      break;
 
    if (SigInt)
      break;
 
    if (mutt_str_equal(buf, MMDF_SEP))
    {
      loc = ftello(adata->fp);
      if (loc < 0)
        goto fail;
 
      count++;
      progress_update(progress, count, (int) (loc / (m->size / 100 + 1)));
 
      mx_alloc_memory(m, m->msg_count);
      e = email_new();
      m->emails[m->msg_count] = e;
      e->offset = loc;
      e->index = m->msg_count;
 
      if (!fgets(buf, sizeof(buf) - 1, adata->fp))
      {
        /* TODO: memory leak??? */
        mutt_debug(LL_DEBUG1, "unexpected EOF\n");
        break;
      }
 
      return_path[0] = '\0';
 
      if (!is_from(buf, return_path, sizeof(return_path), &t))
      {
        if (!mutt_file_seek(adata->fp, loc, SEEK_SET))
        {
          mutt_error(_("Mailbox is corrupt"));
          goto fail;
        }
      }
      else
      {
        e->received = t - mutt_date_local_tz(t);
      }
 
      e->env = mutt_rfc822_read_header(adata->fp, e, false, false);
 
      loc = ftello(adata->fp);
      if (loc < 0)
        goto fail;
 
      if ((e->body->length > 0) && (e->lines > 0))
      {
        tmploc = loc + e->body->length;
 
        if ((tmploc > 0) && (tmploc < m->size))
        {
          if (!mutt_file_seek(adata->fp, tmploc, SEEK_SET) ||
              !fgets(buf, sizeof(buf) - 1, adata->fp) || !mutt_str_equal(MMDF_SEP, buf))
          {
            (void) mutt_file_seek(adata->fp, loc, SEEK_SET);
            e->body->length = -1;
          }
        }
        else
        {
          e->body->length = -1;
        }
      }
      else
      {
        e->body->length = -1;
      }
 
      if (e->body->length < 0)
      {
        lines = -1;
        do
        {
          loc = ftello(adata->fp);
          if (loc < 0)
            goto fail;
          if (!fgets(buf, sizeof(buf) - 1, adata->fp))
            break;
          lines++;
        } while (!mutt_str_equal(buf, MMDF_SEP));
 
        e->lines = lines;
        e->body->length = loc - e->body->offset;
      }
 
      if (TAILQ_EMPTY(&e->env->return_path) && return_path[0])
        mutt_addrlist_parse(&e->env->return_path, return_path);
 
      if (TAILQ_EMPTY(&e->env->from))
        mutt_addrlist_copy(&e->env->from, &e->env->return_path, false);
 
      m->msg_count++;
    }
    else
    {
      mutt_debug(LL_DEBUG1, "corrupt mailbox\n");
      mutt_error(_("Mailbox is corrupt"));
      goto fail;
    }
  }
 
  if (SigInt)
  {
    SigInt = false;
    rc = MX_OPEN_ABORT; /* action aborted */
    goto fail;
  }
 
  rc = MX_OPEN_OK;
fail:
  progress_free(&progress);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mbox_parse_mailbox()

static enum MxOpenReturns mbox_parse_mailbox ( struct Mailbox *  m )

static

Read a mailbox from disk.

Parameters

m

Mailbox

Return values

enum	MxOpenReturns

Note that this function is also called when new mail is appended to the currently open folder, and NOT just when the mailbox is initially read.

Note

It is assumed that the mailbox being read has been locked before this routine gets called. Strange things could happen if it's not!

Definition at line 352 of file mbox.c.

{
  if (!m)
    return MX_OPEN_ERROR;
 
  struct MboxAccountData *adata = mbox_adata_get(m);
  if (!adata)
    return MX_OPEN_ERROR;
 
  struct stat st = { 0 };
  char buf[8192] = { 0 };
  char return_path[256] = { 0 };
  struct Email *e_cur = NULL;
  time_t t = 0;
  int count = 0, lines = 0;
  LOFF_T loc;
  struct Progress *progress = NULL;
  enum MxOpenReturns rc = MX_OPEN_ERROR;
 
  /* Save information about the folder at the time we opened it. */
  if (stat(mailbox_path(m), &st) == -1)
  {
    mutt_perror("%s", mailbox_path(m));
    goto fail;
  }
 
  m->size = st.st_size;
  mutt_file_get_stat_timespec(&adata->mtime, &st, MUTT_STAT_MTIME);
  mutt_file_get_stat_timespec(&adata->atime, &st, MUTT_STAT_ATIME);
 
  if (!m->readonly)
    m->readonly = access(mailbox_path(m), W_OK) ? true : false;
 
  if (m->verbose)
  {
    progress = progress_new(MUTT_PROGRESS_READ, 0);
    progress_set_message(progress, _("Reading %s..."), mailbox_path(m));
  }
 
  loc = ftello(adata->fp);
  if (loc < 0)
  {
    mutt_debug(LL_DEBUG1, "ftello: %s (errno %d)\n", strerror(errno), errno);
    loc = 0;
  }
 
  while ((fgets(buf, sizeof(buf), adata->fp)) && !SigInt)
  {
    if (is_from(buf, return_path, sizeof(return_path), &t))
    {
      /* Save the Content-Length of the previous message */
      if (count > 0)
      {
        struct Email *e = m->emails[m->msg_count - 1];
        if (e->body->length < 0)
        {
          e->body->length = loc - e->body->offset - 1;
          if (e->body->length < 0)
            e->body->length = 0;
        }
        if (e->lines == 0)
          e->lines = lines ? lines - 1 : 0;
      }
 
      count++;
 
      progress_update(progress, count, (int) (ftello(adata->fp) / (m->size / 100 + 1)));
 
      mx_alloc_memory(m, m->msg_count);
 
      m->emails[m->msg_count] = email_new();
      e_cur = m->emails[m->msg_count];
      e_cur->received = t - mutt_date_local_tz(t);
      e_cur->offset = loc;
      e_cur->index = m->msg_count;
 
      e_cur->env = mutt_rfc822_read_header(adata->fp, e_cur, false, false);
 
      /* if we know how long this message is, either just skip over the body,
       * or if we don't know how many lines there are, count them now (this will
       * save time by not having to search for the next message marker).  */
      if (e_cur->body->length > 0)
      {
        LOFF_T tmploc;
 
        loc = ftello(adata->fp);
        if (loc < 0)
        {
          mutt_debug(LL_DEBUG1, "ftello: %s (errno %d)\n", strerror(errno), errno);
          loc = 0;
        }
 
        /* The test below avoids a potential integer overflow if the
         * content-length is huge (thus necessarily invalid).  */
        tmploc = (e_cur->body->length < m->size) ? (loc + e_cur->body->length + 1) : -1;
 
        if ((tmploc > 0) && (tmploc < m->size))
        {
          /* check to see if the content-length looks valid.  we expect to
           * to see a valid message separator at this point in the stream */
          if (!mutt_file_seek(adata->fp, tmploc, SEEK_SET) ||
              !fgets(buf, sizeof(buf), adata->fp) || !mutt_str_startswith(buf, "From "))
          {
            mutt_debug(LL_DEBUG1, "bad content-length in message %d (cl=" OFF_T_FMT ")\n",
                       e_cur->index, e_cur->body->length);
            mutt_debug(LL_DEBUG1, "    LINE: %s", buf);
            /* nope, return the previous position */
            (void) mutt_file_seek(adata->fp, loc, SEEK_SET);
            e_cur->body->length = -1;
          }
        }
        else if (tmploc != m->size)
        {
          /* content-length would put us past the end of the file, so it
           * must be wrong */
          e_cur->body->length = -1;
        }
 
        if (e_cur->body->length != -1)
        {
          /* good content-length.  check to see if we know how many lines
           * are in this message.  */
          if (e_cur->lines == 0)
          {
            int cl = e_cur->body->length;
 
            /* count the number of lines in this message */
            (void) mutt_file_seek(adata->fp, loc, SEEK_SET);
            while (cl-- > 0)
            {
              if (fgetc(adata->fp) == '\n')
                e_cur->lines++;
            }
          }
 
          /* return to the offset of the next message separator */
          (void) mutt_file_seek(adata->fp, tmploc, SEEK_SET);
        }
      }
 
      m->msg_count++;
 
      if (TAILQ_EMPTY(&e_cur->env->return_path) && return_path[0])
      {
        mutt_addrlist_parse(&e_cur->env->return_path, return_path);
      }
 
      if (TAILQ_EMPTY(&e_cur->env->from))
        mutt_addrlist_copy(&e_cur->env->from, &e_cur->env->return_path, false);
 
      lines = 0;
    }
    else
    {
      lines++;
    }
 
    loc = ftello(adata->fp);
  }
 
  /* Only set the content-length of the previous message if we have read more
   * than one message during _this_ invocation.  If this routine is called
   * when new mail is received, we need to make sure not to clobber what
   * previously was the last message since the headers may be sorted.  */
  if (count > 0)
  {
    struct Email *e = m->emails[m->msg_count - 1];
    if (e->body->length < 0)
    {
      e->body->length = ftello(adata->fp) - e->body->offset - 1;
      if (e->body->length < 0)
        e->body->length = 0;
    }
 
    if (e->lines == 0)
      e->lines = lines ? lines - 1 : 0;
  }
 
  if (SigInt)
  {
    SigInt = false;
    rc = MX_OPEN_ABORT;
    goto fail; /* action aborted */
  }
 
  rc = MX_OPEN_OK;
fail:
  progress_free(&progress);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

reopen_mailbox()

static int reopen_mailbox ( struct Mailbox *  m )

static

Close and reopen a mailbox.

Parameters

m

Mailbox

Return values

>0	Success, e.g. MX_STATUS_REOPENED, MX_STATUS_NEW_MAIL
-1	Error

Definition at line 549 of file mbox.c.

{
  if (!m)
    return -1;
 
  struct MboxAccountData *adata = mbox_adata_get(m);
  if (!adata)
    return -1;
 
  bool (*cmp_headers)(const struct Email *, const struct Email *) = NULL;
  struct Email **e_old = NULL;
  int old_msg_count;
  bool msg_mod = false;
  int rc = -1;
 
  /* silent operations */
  m->verbose = false;
 
  /* our heuristics require the old mailbox to be unsorted */
  const enum SortType c_sort = cs_subset_sort(NeoMutt->sub, "sort");
  if (c_sort != SORT_ORDER)
  {
    cs_subset_str_native_set(NeoMutt->sub, "sort", SORT_ORDER, NULL);
    mailbox_changed(m, NT_MAILBOX_RESORT);
    cs_subset_str_native_set(NeoMutt->sub, "sort", c_sort, NULL);
  }
 
  e_old = NULL;
  old_msg_count = 0;
 
  /* simulate a close */
  mutt_hash_free(&m->id_hash);
  mutt_hash_free(&m->subj_hash);
  mutt_hash_free(&m->label_hash);
  FREE(&m->v2r);
  if (m->readonly)
  {
    for (int i = 0; i < m->msg_count; i++)
      email_free(&(m->emails[i])); /* nothing to do! */
    FREE(&m->emails);
  }
  else
  {
    /* save the old headers */
    old_msg_count = m->msg_count;
    e_old = m->emails;
    m->emails = NULL;
  }
 
  m->email_max = 0; /* force allocation of new headers */
  m->msg_count = 0;
  m->vcount = 0;
  m->msg_tagged = 0;
  m->msg_deleted = 0;
  m->msg_new = 0;
  m->msg_unread = 0;
  m->msg_flagged = 0;
  m->changed = false;
  m->id_hash = NULL;
  m->subj_hash = NULL;
  mutt_make_label_hash(m);
 
  switch (m->type)
  {
    case MUTT_MBOX:
    case MUTT_MMDF:
      cmp_headers = email_cmp_strict;
      mutt_file_fclose(&adata->fp);
      adata->fp = mutt_file_fopen(mailbox_path(m), "r");
      if (!adata->fp)
        rc = -1;
      else if (m->type == MUTT_MBOX)
        rc = mbox_parse_mailbox(m);
      else
        rc = mmdf_parse_mailbox(m);
      break;
 
    default:
      rc = -1;
      break;
  }
 
  if (rc == -1)
  {
    /* free the old headers */
    for (int i = 0; i < old_msg_count; i++)
      email_free(&(e_old[i]));
    FREE(&e_old);
 
    m->verbose = true;
    return -1;
  }
 
  mutt_file_touch_atime(fileno(adata->fp));
 
  /* now try to recover the old flags */
 
  if (!m->readonly)
  {
    for (int i = 0; i < m->msg_count; i++)
    {
      bool found = false;
 
      /* some messages have been deleted, and new  messages have been
       * appended at the end; the heuristic is that old messages have then
       * "advanced" towards the beginning of the folder, so we begin the
       * search at index "i" */
      int j;
      for (j = i; j < old_msg_count; j++)
      {
        if (!e_old[j])
          continue;
        if (cmp_headers(m->emails[i], e_old[j]))
        {
          found = true;
          break;
        }
      }
      if (!found)
      {
        for (j = 0; (j < i) && (j < old_msg_count); j++)
        {
          if (!e_old[j])
            continue;
          if (cmp_headers(m->emails[i], e_old[j]))
          {
            found = true;
            break;
          }
        }
      }
 
      if (found)
      {
        m->changed = true;
        if (e_old[j]->changed)
        {
          /* Only update the flags if the old header was changed;
           * otherwise, the header may have been modified externally,
           * and we don't want to lose _those_ changes */
          mutt_set_flag(m, m->emails[i], MUTT_FLAG, e_old[j]->flagged, true);
          mutt_set_flag(m, m->emails[i], MUTT_REPLIED, e_old[j]->replied, true);
          mutt_set_flag(m, m->emails[i], MUTT_OLD, e_old[j]->old, true);
          mutt_set_flag(m, m->emails[i], MUTT_READ, e_old[j]->read, true);
        }
        mutt_set_flag(m, m->emails[i], MUTT_DELETE, e_old[j]->deleted, true);
        mutt_set_flag(m, m->emails[i], MUTT_PURGE, e_old[j]->purge, true);
        mutt_set_flag(m, m->emails[i], MUTT_TAG, e_old[j]->tagged, true);
 
        /* we don't need this header any more */
        email_free(&(e_old[j]));
      }
    }
 
    /* free the remaining old emails */
    for (int j = 0; j < old_msg_count; j++)
    {
      if (e_old[j])
      {
        email_free(&(e_old[j]));
        msg_mod = true;
      }
    }
    FREE(&e_old);
  }
 
  mailbox_changed(m, NT_MAILBOX_UPDATE);
  m->verbose = true;
 
  return (m->changed || msg_mod) ? MX_STATUS_REOPENED : MX_STATUS_NEW_MAIL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mbox_has_new()

static bool mbox_has_new ( struct Mailbox *  m )

static

Does the mailbox have new mail.

Parameters

m

Mailbox

Return values

true	The mailbox has at least 1 new messages (not old)
false	otherwise

Definition at line 727 of file mbox.c.

{
  for (int i = 0; i < m->msg_count; i++)
  {
    struct Email *e = m->emails[i];
    if (!e)
      break;
    if (!e->deleted && !e->read && !e->old)
      return true;
  }
  return false;
}

Here is the caller graph for this function:

mbox_reset_atime()

void mbox_reset_atime	(	struct Mailbox *	m,
		struct stat *	st
	)

Reset the access time on the mailbox file.

Parameters

m	Mailbox
st	Timestamp

if mailbox has at least 1 new message, sets mtime > atime of mailbox so mailbox check reports new mail

Definition at line 748 of file mbox.c.

{
  struct stat st2 = { 0 };
  if (!st)
  {
    if (stat(mailbox_path(m), &st2) < 0)
      return;
    st = &st2;
  }
 
  struct utimbuf utimebuf = { 0 };
  utimebuf.actime = st->st_atime;
  utimebuf.modtime = st->st_mtime;
 
  /* When $mbox_check_recent is set, existing new mail is ignored, so do not
   * reset the atime to mtime-1 to signal new mail.  */
  const bool c_mail_check_recent = cs_subset_bool(NeoMutt->sub, "mail_check_recent");
  if (!c_mail_check_recent && (utimebuf.actime >= utimebuf.modtime) && mbox_has_new(m))
  {
    utimebuf.actime = utimebuf.modtime - 1;
  }
 
  utime(mailbox_path(m), &utimebuf);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mbox_open_readwrite()

static FILE * mbox_open_readwrite ( struct Mailbox *  m )

static

Open an mbox read-write.

Parameters

m

Mailbox

Return values

ptr	FILE handle

This function ensures that the FILE and readonly flag are changed atomically.

Definition at line 803 of file mbox.c.

{
  FILE *fp = mutt_file_fopen(mailbox_path(m), "r+");
  if (fp)
    m->readonly = false;
  return fp;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mbox_open_readonly()

static FILE * mbox_open_readonly ( struct Mailbox *  m )

static

Open an mbox read-only.

Parameters

m

Mailbox

Return values

ptr	FILE handle

This function ensures that the FILE and readonly flag are changed atomically.

Definition at line 818 of file mbox.c.

{
  FILE *fp = mutt_file_fopen(mailbox_path(m), "r");
  if (fp)
    m->readonly = true;
  return fp;
}

Here is the call graph for this function:

Here is the caller graph for this function: