mx.c File Reference

Mailbox multiplexor. More...

#include "config.h"
#include <errno.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <time.h>
#include <unistd.h>
#include "mutt/lib.h"
#include "address/lib.h"
#include "config/lib.h"
#include "email/lib.h"
#include "core/lib.h"
#include "alias/lib.h"
#include "gui/lib.h"
#include "mutt.h"
#include "mx.h"
#include "compmbox/lib.h"
#include "imap/lib.h"
#include "key/lib.h"
#include "maildir/lib.h"
#include "mbox/lib.h"
#include "menu/lib.h"
#include "mh/lib.h"
#include "nntp/lib.h"
#include "pop/lib.h"
#include "question/lib.h"
#include "copy.h"
#include "external.h"
#include "globals.h"
#include "hook.h"
#include "mutt_header.h"
#include "mutt_logging.h"
#include "mutt_mailbox.h"
#include "muttlib.h"
#include "nntp/mdata.h"
#include "protos.h"
#include "notmuch/lib.h"
#include <libintl.h>

Include dependency graph for mx.c:

Go to the source code of this file.

Functions
const struct MxOps *	mx_get_ops (enum MailboxType type)
	Get mailbox operations.
static bool	mutt_is_spool (const char *str)
	Is this the spool_file?
int	mx_access (const char *path, int flags)
	Wrapper for access, checks permissions on a given mailbox.
static bool	mx_open_mailbox_append (struct Mailbox *m, OpenMailboxFlags flags)
	Open a mailbox for appending.
bool	mx_mbox_ac_link (struct Mailbox *m)
	Link a Mailbox to an existing or new Account.
bool	mx_mbox_open (struct Mailbox *m, OpenMailboxFlags flags)
	Open a mailbox and parse it.
void	mx_fastclose_mailbox (struct Mailbox *m, bool keep_account)
	Free up memory associated with the Mailbox.
static enum MxStatus	sync_mailbox (struct Mailbox *m)
	Save changes to disk.
static int	trash_append (struct Mailbox *m)
	Move deleted mails to the trash folder.
enum MxStatus	mx_mbox_close (struct Mailbox *m)
	Save changes and close mailbox.
enum MxStatus	mx_mbox_sync (struct Mailbox *m)
	Save changes to mailbox.
struct Message *	mx_msg_open_new (struct Mailbox *m, const struct Email *e, MsgOpenFlags flags)
	Open a new message.
enum MxStatus	mx_mbox_check (struct Mailbox *m)
	Check for new mail - Wrapper for MxOps::mbox_check()
struct Message *	mx_msg_open (struct Mailbox *m, struct Email *e)
	Return a stream pointer for a message.
int	mx_msg_commit (struct Mailbox *m, struct Message *msg)
	Commit a message to a folder - Wrapper for MxOps::msg_commit()
int	mx_msg_close (struct Mailbox *m, struct Message **ptr)
	Close a message.
void	mx_alloc_memory (struct Mailbox *m, int req_size)
	Create storage for the emails.
int	mx_path_is_empty (struct Buffer *path)
	Is the mailbox empty.
int	mx_tags_edit (struct Mailbox *m, const char *tags, struct Buffer *buf)
	Start the tag editor of the mailbox.
int	mx_tags_commit (struct Mailbox *m, struct Email *e, const char *tags)
	Save tags to the Mailbox - Wrapper for MxOps::tags_commit()
bool	mx_tags_is_supported (struct Mailbox *m)
	Return true if mailbox support tagging.
enum MailboxType	mx_path_probe (const char *path)
	Find a mailbox that understands a path.
int	mx_path_canon (struct Buffer *path, const char *folder, enum MailboxType *type)
	Canonicalise a mailbox path - Wrapper for MxOps::path_canon()
int	mx_path_canon2 (struct Mailbox *m, const char *folder)
	Canonicalise the path to realpath.
int	mx_msg_padding_size (struct Mailbox *m)
	Bytes of padding between messages - Wrapper for MxOps::msg_padding_size()
struct Account *	mx_ac_find (struct Mailbox *m)
	Find the Account owning a Mailbox.
struct Mailbox *	mx_mbox_find (struct Account *a, const char *path)
	Find a Mailbox on an Account.
struct Mailbox *	mx_mbox_find2 (const char *path)
	Find a Mailbox on an Account.
struct Mailbox *	mx_path_resolve (const char *path)
	Get a Mailbox for a path.
static struct Mailbox *	mx_mbox_find_by_name_ac (struct Account *a, const char *name)
	Find a Mailbox with given name under an Account.
static struct Mailbox *	mx_mbox_find_by_name (const char *name)
	Find a Mailbox with given name.
struct Mailbox *	mx_resolve (const char *path_or_name)
	Get a Mailbox from either a path or name.
bool	mx_ac_add (struct Account *a, struct Mailbox *m)
	Add a Mailbox to an Account - Wrapper for MxOps::ac_add()
int	mx_ac_remove (struct Mailbox *m, bool keep_account)
	Remove a Mailbox from an Account and delete Account if empty.
enum MxStatus	mx_mbox_check_stats (struct Mailbox *m, uint8_t flags)
	Check the statistics for a mailbox - Wrapper for MxOps::mbox_check_stats()
int	mx_save_hcache (struct Mailbox *m, struct Email *e)
	Save message to the header cache - Wrapper for MxOps::msg_save_hcache()
enum MailboxType	mx_type (struct Mailbox *m)
	Return the type of the Mailbox.
int	mx_toggle_write (struct Mailbox *m)
	Toggle the mailbox's readonly flag.

Variables
static const struct Mapping	MboxTypeMap []
	Lookup table of mailbox types.
const struct EnumDef	MboxTypeDef
	Data for the $mbox_type enumeration.
static const struct MxOps *	MxOps []
	All the Mailbox backends.

Detailed Description

Mailbox multiplexor.

Authors

• Michael R. Elkins
• Thomas Roessler
• Richard Russon
• Mehdi Abaakouk
• Pietro Cerutti
• Austin Ray
• Reto Brunner
• Dennis Schön

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

Function Documentation

mx_get_ops()

const struct MxOps * mx_get_ops

(

enum MailboxType

type

)

Get mailbox operations.

Parameters

type	Mailbox type

Return values

ptr	Mailbox function
NULL	Error

Definition at line 127 of file mx.c.

{
  for (const struct MxOps **ops = MxOps; *ops; ops++)
    if ((*ops)->type == type)
      return *ops;
 
  return NULL;
}

Here is the caller graph for this function:

mutt_is_spool()

static bool mutt_is_spool ( const char *  str )

static

Is this the spool_file?

Parameters

str	Name to check

Return values

true	It is the spool_file

Definition at line 141 of file mx.c.

{
  const char *const c_spool_file = cs_subset_string(NeoMutt->sub, "spool_file");
  if (mutt_str_equal(str, c_spool_file))
    return true;
 
  struct Url *ua = url_parse(str);
  struct Url *ub = url_parse(c_spool_file);
 
  const bool is_spool = ua && ub && (ua->scheme == ub->scheme) &&
                        mutt_istr_equal(ua->host, ub->host) &&
                        mutt_istr_equal(ua->path, ub->path) &&
                        (!ua->user || !ub->user || mutt_str_equal(ua->user, ub->user));
 
  url_free(&ua);
  url_free(&ub);
  return is_spool;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mx_access()

int mx_access	(	const char *	path,
		int	flags
	)

Wrapper for access, checks permissions on a given mailbox.

Parameters

path	Path of mailbox
flags	Flags, e.g. W_OK

Return values

0	Success, allowed
<0	Failure, not allowed

We may be interested in using ACL-style flags at some point, currently we use the normal access() flags.

Definition at line 170 of file mx.c.

{
  if (imap_path_probe(path, NULL) == MUTT_IMAP)
    return imap_access(path);
 
  return access(path, flags);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mx_open_mailbox_append()

static bool mx_open_mailbox_append ( struct Mailbox *  m, OpenMailboxFlags  flags  )

static

Open a mailbox for appending.

Parameters

m	Mailbox
flags	Flags, see OpenMailboxFlags

Return values

true	Success
false	Failure

Definition at line 185 of file mx.c.

{
  if (!m)
    return false;
 
  struct stat st = { 0 };
 
  m->append = true;
  if ((m->type == MUTT_UNKNOWN) || (m->type == MUTT_MAILBOX_ERROR))
  {
    m->type = mx_path_probe(mailbox_path(m));
 
    if (m->type == MUTT_UNKNOWN)
    {
      if (flags & (MUTT_APPEND | MUTT_NEWFOLDER))
      {
        m->type = MUTT_MAILBOX_ERROR;
      }
      else
      {
        mutt_error(_("%s is not a mailbox"), mailbox_path(m));
        return false;
      }
    }
 
    if (m->type == MUTT_MAILBOX_ERROR)
    {
      if (stat(mailbox_path(m), &st) == -1)
      {
        if (errno == ENOENT)
        {
          if (mutt_comp_can_append(m))
            m->type = MUTT_COMPRESSED;
          else
            m->type = cs_subset_enum(NeoMutt->sub, "mbox_type");
          flags |= MUTT_APPENDNEW;
        }
        else
        {
          mutt_perror("%s", mailbox_path(m));
          return false;
        }
      }
      else
      {
        return false;
      }
    }
 
    m->mx_ops = mx_get_ops(m->type);
  }
 
  if (!m->mx_ops || !m->mx_ops->mbox_open_append)
    return false;
 
  const bool rc = m->mx_ops->mbox_open_append(m, flags);
  m->opened++;
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mx_mbox_ac_link()

bool mx_mbox_ac_link

(

struct Mailbox *

m

)

Link a Mailbox to an existing or new Account.

Parameters

m	Mailbox to link

Return values

true	Success
false	Failure

Definition at line 251 of file mx.c.

{
  if (!m)
    return false;
 
  if (m->account)
    return true;
 
  struct Account *a = mx_ac_find(m);
  const bool new_account = !a;
  if (new_account)
  {
    a = account_new(NULL, NeoMutt->sub);
    a->type = m->type;
  }
  if (!mx_ac_add(a, m))
  {
    if (new_account)
    {
      account_free(&a);
    }
    return false;
  }
  if (new_account)
  {
    neomutt_account_add(NeoMutt, a);
  }
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mx_mbox_open()

bool mx_mbox_open	(	struct Mailbox *	m,
		OpenMailboxFlags	flags
	)

Open a mailbox and parse it.

Parameters

m	Mailbox to open
flags	Flags, see OpenMailboxFlags

Return values

true	Success
false	Error

Definition at line 288 of file mx.c.

{
  if (!m)
    return false;
 
  if ((m->type == MUTT_UNKNOWN) && (flags & (MUTT_NEWFOLDER | MUTT_APPEND)))
  {
    m->type = cs_subset_enum(NeoMutt->sub, "mbox_type");
    m->mx_ops = mx_get_ops(m->type);
  }
 
  const bool newly_linked_account = !m->account;
  if (newly_linked_account)
  {
    if (!mx_mbox_ac_link(m))
    {
      return false;
    }
  }
 
  m->verbose = !(flags & MUTT_QUIET);
  m->readonly = (flags & MUTT_READONLY);
  m->peekonly = (flags & MUTT_PEEK);
 
  if (flags & (MUTT_APPEND | MUTT_NEWFOLDER))
  {
    if (!mx_open_mailbox_append(m, flags))
    {
      goto error;
    }
    return true;
  }
 
  if (m->opened > 0)
  {
    m->opened++;
    return true;
  }
 
  m->size = 0;
  m->msg_unread = 0;
  m->msg_flagged = 0;
  m->rights = MUTT_ACL_ALL;
 
  if (m->type == MUTT_UNKNOWN)
  {
    m->type = mx_path_probe(mailbox_path(m));
    m->mx_ops = mx_get_ops(m->type);
  }
 
  if ((m->type == MUTT_UNKNOWN) || (m->type == MUTT_MAILBOX_ERROR) || !m->mx_ops)
  {
    if (m->type == MUTT_MAILBOX_ERROR)
      mutt_perror("%s", mailbox_path(m));
    else if ((m->type == MUTT_UNKNOWN) || !m->mx_ops)
      mutt_error(_("%s is not a mailbox"), mailbox_path(m));
    goto error;
  }
 
  mutt_make_label_hash(m);
 
  /* if the user has a 'push' command in their .neomuttrc, or in a folder-hook,
   * it will cause the progress messages not to be displayed because
   * mutt_refresh() will think we are in the middle of a macro.  so set a
   * flag to indicate that we should really refresh the screen.  */
  OptForceRefresh = true;
 
  if (m->verbose)
    mutt_message(_("Reading %s..."), mailbox_path(m));
 
  // Clear out any existing emails
  for (int i = 0; i < m->email_max; i++)
  {
    email_free(&m->emails[i]);
  }
 
  m->msg_count = 0;
  m->msg_unread = 0;
  m->msg_flagged = 0;
  m->msg_new = 0;
  m->msg_deleted = 0;
  m->msg_tagged = 0;
  m->vcount = 0;
 
  enum MxOpenReturns rc = m->mx_ops->mbox_open(m);
  m->opened++;
 
  if ((rc == MX_OPEN_OK) || (rc == MX_OPEN_ABORT))
  {
    if ((flags & MUTT_NOSORT) == 0)
    {
      /* avoid unnecessary work since the mailbox is completely unthreaded
       * to begin with */
      OptSortSubthreads = false;
      OptNeedRescore = false;
    }
    if (m->verbose)
      mutt_clear_error();
    if (rc == MX_OPEN_ABORT)
    {
      mutt_error(_("Reading from %s interrupted..."), mailbox_path(m));
    }
  }
  else
  {
    goto error;
  }
 
  if (!m->peekonly)
    m->has_new = false;
  OptForceRefresh = false;
 
  return true;
 
error:
  mx_fastclose_mailbox(m, newly_linked_account);
  if (newly_linked_account)
    account_mailbox_remove(m->account, m);
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mx_fastclose_mailbox()

void mx_fastclose_mailbox	(	struct Mailbox *	m,
		bool	keep_account
	)

Free up memory associated with the Mailbox.

Parameters

m	Mailbox
keep_account	Make sure not to remove the mailbox's account

Definition at line 414 of file mx.c.

{
  if (!m)
    return;
 
  m->opened--;
  if (m->opened != 0)
    return;
 
  /* never announce that a mailbox we've just left has new mail.
   * TODO: really belongs in mx_mbox_close, but this is a nice hook point */
  if (!m->peekonly)
    mutt_mailbox_set_notified(m);
 
  if (m->mx_ops)
    m->mx_ops->mbox_close(m);
 
  mutt_hash_free(&m->subj_hash);
  mutt_hash_free(&m->id_hash);
  mutt_hash_free(&m->label_hash);
 
  if (m->emails)
  {
    for (int i = 0; i < m->msg_count; i++)
    {
      if (!m->emails[i])
        break;
      email_free(&m->emails[i]);
    }
  }
 
  if (!m->visible)
  {
    mx_ac_remove(m, keep_account);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

sync_mailbox()

static enum MxStatus sync_mailbox ( struct Mailbox *  m )

static

Save changes to disk.

Parameters

m

Mailbox

Return values

enum

MxStatus

Definition at line 456 of file mx.c.

{
  if (!m || !m->mx_ops || !m->mx_ops->mbox_sync)
    return MX_STATUS_ERROR;
 
  if (m->verbose)
  {
    /* L10N: Displayed before/as a mailbox is being synced */
    mutt_message(_("Writing %s..."), mailbox_path(m));
  }
 
  enum MxStatus rc = m->mx_ops->mbox_sync(m);
  if (rc != MX_STATUS_OK)
  {
    mutt_debug(LL_DEBUG2, "mbox_sync returned: %d\n", rc);
    if ((rc == MX_STATUS_ERROR) && m->verbose)
    {
      /* L10N: Displayed if a mailbox sync fails */
      mutt_error(_("Unable to write %s"), mailbox_path(m));
    }
  }
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

trash_append()

static int trash_append ( struct Mailbox *  m )

static

Move deleted mails to the trash folder.

Parameters

m

Mailbox

Return values

0	Success
-1	Failure

Definition at line 487 of file mx.c.

{
  if (!m)
    return -1;
 
  struct stat st = { 0 };
  struct stat stc = { 0 };
  int rc;
 
  const bool c_maildir_trash = cs_subset_bool(NeoMutt->sub, "maildir_trash");
  const char *const c_trash = cs_subset_string(NeoMutt->sub, "trash");
  if (!c_trash || (m->msg_deleted == 0) || ((m->type == MUTT_MAILDIR) && c_maildir_trash))
  {
    return 0;
  }
 
  int delmsgcount = 0;
  int first_del = -1;
  for (int i = 0; i < m->msg_count; i++)
  {
    struct Email *e = m->emails[i];
    if (!e)
      break;
 
    if (e->deleted && !e->purge)
    {
      if (first_del < 0)
        first_del = i;
      delmsgcount++;
    }
  }
 
  if (delmsgcount == 0)
    return 0; /* nothing to be done */
 
  /* avoid the "append messages" prompt */
  const bool c_confirm_append = cs_subset_bool(NeoMutt->sub, "confirm_append");
  cs_subset_str_native_set(NeoMutt->sub, "confirm_append", false, NULL);
  rc = mutt_save_confirm(c_trash, &st);
  cs_subset_str_native_set(NeoMutt->sub, "confirm_append", c_confirm_append, NULL);
  if (rc != 0)
  {
    /* L10N: Although we know the precise number of messages, we do not show it to the user.
       So feel free to use a "generic plural" as plural translation if your language has one. */
    mutt_error(ngettext("message not deleted", "messages not deleted", delmsgcount));
    return -1;
  }
 
  if ((lstat(mailbox_path(m), &stc) == 0) && (stc.st_ino == st.st_ino) &&
      (stc.st_dev == st.st_dev) && (stc.st_rdev == st.st_rdev))
  {
    return 0; /* we are in the trash folder: simple sync */
  }
 
  if ((m->type == MUTT_IMAP) && (imap_path_probe(c_trash, NULL) == MUTT_IMAP))
  {
    if (imap_fast_trash(m, c_trash) == 0)
      return 0;
  }
 
  struct Mailbox *m_trash = mx_path_resolve(c_trash);
  const bool old_append = m_trash->append;
  if (!mx_mbox_open(m_trash, MUTT_APPEND))
  {
    mutt_error(_("Can't open trash folder"));
    mailbox_free(&m_trash);
    return -1;
  }
 
  /* continue from initial scan above */
  for (int i = first_del; i < m->msg_count; i++)
  {
    struct Email *e = m->emails[i];
    if (!e)
      break;
 
    if (e->deleted && !e->purge)
    {
      if (mutt_append_message(m_trash, m, e, NULL, MUTT_CM_NO_FLAGS, CH_NO_FLAGS) == -1)
      {
        mx_mbox_close(m_trash);
        // L10N: Displayed if appending to $trash fails when syncing or closing a mailbox
        mutt_error(_("Unable to append to trash folder"));
        m_trash->append = old_append;
        mailbox_free(&m_trash);
        return -1;
      }
    }
  }
 
  mx_mbox_close(m_trash);
  m_trash->append = old_append;
  mailbox_free(&m_trash);
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mx_mbox_close()

enum MxStatus mx_mbox_close

(

struct Mailbox *

m

)

Save changes and close mailbox.

Parameters

m

Mailbox

Return values

enum

MxStatus

Note

The flag retvals come from a call to a backend sync function

It's very important to ensure the mailbox is properly closed before free'ing the context. For selected mailboxes, IMAP will cache the context inside connection->adata until imap_close_mailbox() removes it. Readonly, dontwrite, and append mailboxes are guaranteed to call mx_fastclose_mailbox(), so for most of NeoMutt's code you won't see return value checks for temporary contexts.

Definition at line 598 of file mx.c.

{
  if (!m)
    return MX_STATUS_ERROR;
 
  const bool c_mail_check_recent = cs_subset_bool(NeoMutt->sub, "mail_check_recent");
  if (c_mail_check_recent && !m->peekonly)
    m->has_new = false;
 
  if (m->readonly || m->dontwrite || m->append || m->peekonly)
  {
    mx_fastclose_mailbox(m, false);
    return 0;
  }
 
  int i, read_msgs = 0;
  enum MxStatus rc = MX_STATUS_ERROR;
  enum QuadOption move_messages = MUTT_NO;
  enum QuadOption purge = MUTT_YES;
  struct Buffer *mbox = NULL;
  struct Buffer *buf = buf_pool_get();
 
  if ((m->msg_unread != 0) && (m->type == MUTT_NNTP))
  {
    struct NntpMboxData *mdata = m->mdata;
 
    if (mdata && mdata->adata && mdata->group)
    {
      enum QuadOption ans = query_quadoption(_("Mark all articles read?"),
                                             NeoMutt->sub, "catchup_newsgroup");
      if (ans == MUTT_ABORT)
        goto cleanup;
      if (ans == MUTT_YES)
        mutt_newsgroup_catchup(m, mdata->adata, mdata->group);
    }
  }
 
  const bool c_keep_flagged = cs_subset_bool(NeoMutt->sub, "keep_flagged");
  for (i = 0; i < m->msg_count; i++)
  {
    struct Email *e = m->emails[i];
    if (!e)
      break;
 
    if (!e->deleted && e->read && !(e->flagged && c_keep_flagged))
      read_msgs++;
  }
 
  /* don't need to move articles from newsgroup */
  if (m->type == MUTT_NNTP)
    read_msgs = 0;
 
  const enum QuadOption c_move = cs_subset_quad(NeoMutt->sub, "move");
  if ((read_msgs != 0) && (c_move != MUTT_NO))
  {
    bool is_spool;
    mbox = buf_pool_get();
 
    char *p = mutt_find_hook(MUTT_MBOX_HOOK, mailbox_path(m));
    if (p)
    {
      is_spool = true;
      buf_strcpy(mbox, p);
    }
    else
    {
      const char *const c_mbox = cs_subset_string(NeoMutt->sub, "mbox");
      buf_strcpy(mbox, c_mbox);
      is_spool = mutt_is_spool(mailbox_path(m)) && !mutt_is_spool(buf_string(mbox));
    }
 
    if (is_spool && !buf_is_empty(mbox))
    {
      buf_expand_path(mbox);
      buf_printf(buf,
                 /* L10N: The first argument is the number of read messages to be
                            moved, the second argument is the target mailbox. */
                 ngettext("Move %d read message to %s?", "Move %d read messages to %s?", read_msgs),
                 read_msgs, buf_string(mbox));
      move_messages = query_quadoption(buf_string(buf), NeoMutt->sub, "move");
      if (move_messages == MUTT_ABORT)
        goto cleanup;
    }
  }
 
  /* There is no point in asking whether or not to purge if we are
   * just marking messages as "trash".  */
  const bool c_maildir_trash = cs_subset_bool(NeoMutt->sub, "maildir_trash");
  if ((m->msg_deleted != 0) && !((m->type == MUTT_MAILDIR) && c_maildir_trash))
  {
    buf_printf(buf, ngettext("Purge %d deleted message?", "Purge %d deleted messages?", m->msg_deleted),
               m->msg_deleted);
    purge = query_quadoption(buf_string(buf), NeoMutt->sub, "delete");
    if (purge == MUTT_ABORT)
      goto cleanup;
  }
 
  const bool c_mark_old = cs_subset_bool(NeoMutt->sub, "mark_old");
  if (c_mark_old && !m->peekonly)
  {
    for (i = 0; i < m->msg_count; i++)
    {
      struct Email *e = m->emails[i];
      if (!e)
        break;
      if (!e->deleted && !e->old && !e->read)
        mutt_set_flag(m, e, MUTT_OLD, true, true);
    }
  }
 
  if (move_messages)
  {
    if (m->verbose)
      mutt_message(_("Moving read messages to %s..."), buf_string(mbox));
 
    /* try to use server-side copy first */
    i = 1;
 
    if ((m->type == MUTT_IMAP) && (imap_path_probe(buf_string(mbox), NULL) == MUTT_IMAP))
    {
      /* add messages for moving, and clear old tags, if any */
      struct EmailArray ea = ARRAY_HEAD_INITIALIZER;
      for (i = 0; i < m->msg_count; i++)
      {
        struct Email *e = m->emails[i];
        if (!e)
          break;
 
        if (e->read && !e->deleted && !(e->flagged && c_keep_flagged))
        {
          e->tagged = true;
          ARRAY_ADD(&ea, e);
        }
        else
        {
          e->tagged = false;
        }
      }
 
      i = imap_copy_messages(m, &ea, buf_string(mbox), SAVE_MOVE);
      if (i == 0)
      {
        const bool c_delete_untag = cs_subset_bool(NeoMutt->sub, "delete_untag");
        if (c_delete_untag)
        {
          struct Email **ep = NULL;
          ARRAY_FOREACH(ep, &ea)
          {
            mutt_set_flag(m, *ep, MUTT_TAG, false, true);
          }
        }
      }
      ARRAY_FREE(&ea);
    }
 
    if (i == 0) /* success */
    {
      mutt_clear_error();
    }
    else if (i == -1) /* horrible error, bail */
    {
      goto cleanup;
    }
    else /* use regular append-copy mode */
    {
      struct Mailbox *m_read = mx_path_resolve(buf_string(mbox));
      if (!mx_mbox_open(m_read, MUTT_APPEND))
      {
        mailbox_free(&m_read);
        goto cleanup;
      }
 
      for (i = 0; i < m->msg_count; i++)
      {
        struct Email *e = m->emails[i];
        if (!e)
          break;
        if (e->read && !e->deleted && !(e->flagged && c_keep_flagged))
        {
          if (mutt_append_message(m_read, m, e, NULL, MUTT_CM_NO_FLAGS, CH_UPDATE_LEN) == 0)
          {
            mutt_set_flag(m, e, MUTT_DELETE, true, true);
            mutt_set_flag(m, e, MUTT_PURGE, true, true);
          }
          else
          {
            mx_mbox_close(m_read);
            goto cleanup;
          }
        }
      }
 
      mx_mbox_close(m_read);
    }
  }
  else if (!m->changed && (m->msg_deleted == 0))
  {
    if (m->verbose)
      mutt_message(_("Mailbox is unchanged"));
    if ((m->type == MUTT_MBOX) || (m->type == MUTT_MMDF))
      mbox_reset_atime(m, NULL);
    mx_fastclose_mailbox(m, false);
    rc = MX_STATUS_OK;
    goto cleanup;
  }
 
  /* copy mails to the trash before expunging */
  const char *const c_trash = cs_subset_string(NeoMutt->sub, "trash");
  const struct Mailbox *m_trash = mx_mbox_find(m->account, c_trash);
  if (purge && (m->msg_deleted != 0) && (m != m_trash))
  {
    if (trash_append(m) != 0)
      goto cleanup;
  }
 
  /* allow IMAP to preserve the deleted flag across sessions */
  if (m->type == MUTT_IMAP)
  {
    const enum MxStatus check = imap_sync_mailbox(m, (purge != MUTT_NO), true);
    if (check == MX_STATUS_ERROR)
    {
      rc = check;
      goto cleanup;
    }
  }
  else
  {
    if (purge == MUTT_NO)
    {
      for (i = 0; i < m->msg_count; i++)
      {
        struct Email *e = m->emails[i];
        if (!e)
          break;
 
        e->deleted = false;
        e->purge = false;
      }
      m->msg_deleted = 0;
    }
 
    if (m->changed || (m->msg_deleted != 0))
    {
      enum MxStatus check = sync_mailbox(m);
      if (check != MX_STATUS_OK)
      {
        rc = check;
        goto cleanup;
      }
    }
  }
 
  if (m->verbose)
  {
    if (move_messages)
    {
      mutt_message(_("%d kept, %d moved, %d deleted"),
                   m->msg_count - m->msg_deleted, read_msgs, m->msg_deleted);
    }
    else
    {
      mutt_message(_("%d kept, %d deleted"), m->msg_count - m->msg_deleted, m->msg_deleted);
    }
  }
 
  const bool c_save_empty = cs_subset_bool(NeoMutt->sub, "save_empty");
  if ((m->msg_count == m->msg_deleted) &&
      ((m->type == MUTT_MMDF) || (m->type == MUTT_MBOX)) &&
      !mutt_is_spool(mailbox_path(m)) && !c_save_empty)
  {
    mutt_file_unlink_empty(mailbox_path(m));
  }
 
  if ((purge == MUTT_YES) && (m->msg_deleted != 0))
  {
    for (i = 0; i < m->msg_count; i++)
    {
      struct Email *e = m->emails[i];
      if (!e)
        break;
      if (e->deleted && !e->read)
      {
        m->msg_unread--;
        if (!e->old)
          m->msg_new--;
      }
      if (e->deleted && e->flagged)
        m->msg_flagged--;
    }
  }
 
  mx_fastclose_mailbox(m, false);
 
  rc = MX_STATUS_OK;
 
cleanup:
  buf_pool_release(&mbox);
  buf_pool_release(&buf);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mx_mbox_sync()

enum MxStatus mx_mbox_sync

(

struct Mailbox *

m

)

Save changes to mailbox.

Parameters

[in]

m

Mailbox

Return values

enum

MxStatus

Note

The flag retvals come from a call to a backend sync function

Definition at line 906 of file mx.c.

{
  if (!m)
    return MX_STATUS_ERROR;
 
  enum MxStatus rc = MX_STATUS_OK;
  int purge = 1;
  int msgcount, deleted;
 
  if (m->dontwrite)
  {
    char buf[512] = { 0 };
    char tmp[768] = { 0 };
    if (km_expand_key(buf, sizeof(buf), km_find_func(MENU_INDEX, OP_TOGGLE_WRITE)))
      snprintf(tmp, sizeof(tmp), _(" Press '%s' to toggle write"), buf);
    else
      mutt_str_copy(tmp, _("Use 'toggle-write' to re-enable write"), sizeof(tmp));
 
    mutt_error(_("Mailbox is marked unwritable. %s"), tmp);
    return MX_STATUS_ERROR;
  }
  else if (m->readonly)
  {
    mutt_error(_("Mailbox is read-only"));
    return MX_STATUS_ERROR;
  }
 
  if (!m->changed && (m->msg_deleted == 0))
  {
    if (m->verbose)
      mutt_message(_("Mailbox is unchanged"));
    return MX_STATUS_OK;
  }
 
  if (m->msg_deleted != 0)
  {
    char buf[128] = { 0 };
 
    snprintf(buf, sizeof(buf),
             ngettext("Purge %d deleted message?", "Purge %d deleted messages?", m->msg_deleted),
             m->msg_deleted);
    purge = query_quadoption(buf, NeoMutt->sub, "delete");
    if (purge == MUTT_ABORT)
      return MX_STATUS_ERROR;
    if (purge == MUTT_NO)
    {
      if (!m->changed)
        return MX_STATUS_OK; /* nothing to do! */
      /* let IMAP servers hold on to D flags */
      if (m->type != MUTT_IMAP)
      {
        for (int i = 0; i < m->msg_count; i++)
        {
          struct Email *e = m->emails[i];
          if (!e)
            break;
          e->deleted = false;
          e->purge = false;
        }
        m->msg_deleted = 0;
      }
    }
    mailbox_changed(m, NT_MAILBOX_UNTAG);
  }
 
  /* really only for IMAP - imap_sync_mailbox results in a call to
   * ctx_update_tables, so m->msg_deleted is 0 when it comes back */
  msgcount = m->msg_count;
  deleted = m->msg_deleted;
 
  const char *const c_trash = cs_subset_string(NeoMutt->sub, "trash");
  const struct Mailbox *m_trash = mx_mbox_find(m->account, c_trash);
  if (purge && (m->msg_deleted != 0) && (m != m_trash))
  {
    if (trash_append(m) != 0)
      return MX_STATUS_OK;
  }
 
  if (m->type == MUTT_IMAP)
    rc = imap_sync_mailbox(m, purge, false);
  else
    rc = sync_mailbox(m);
  if (rc != MX_STATUS_ERROR)
  {
    if ((m->type == MUTT_IMAP) && !purge)
    {
      if (m->verbose)
        mutt_message(_("Mailbox checkpointed"));
    }
    else
    {
      if (m->verbose)
        mutt_message(_("%d kept, %d deleted"), msgcount - deleted, deleted);
    }
 
    mutt_sleep(0);
 
    const bool c_save_empty = cs_subset_bool(NeoMutt->sub, "save_empty");
    if ((m->msg_count == m->msg_deleted) &&
        ((m->type == MUTT_MBOX) || (m->type == MUTT_MMDF)) &&
        !mutt_is_spool(mailbox_path(m)) && !c_save_empty)
    {
      unlink(mailbox_path(m));
      mx_fastclose_mailbox(m, false);
      return MX_STATUS_OK;
    }
 
    /* if we haven't deleted any messages, we don't need to resort
     * ... except for certain folder formats which need "unsorted"
     * sort order in order to synchronize folders.
     *
     * MH and maildir are safe.  mbox-style seems to need re-sorting,
     * at least with the new threading code.  */
    if (purge || ((m->type != MUTT_MAILDIR) && (m->type != MUTT_MH)))
    {
      /* IMAP does this automatically after handling EXPUNGE */
      if (m->type != MUTT_IMAP)
      {
        mailbox_changed(m, NT_MAILBOX_UPDATE);
        mailbox_changed(m, NT_MAILBOX_RESORT);
      }
    }
  }
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mx_msg_open_new()

struct Message * mx_msg_open_new	(	struct Mailbox *	m,
		const struct Email *	e,
		MsgOpenFlags	flags
	)

Open a new message.

Parameters

m	Destination mailbox
e	Message being copied (required for maildir support, because the filename depends on the message flags)
flags	Flags, see MsgOpenFlags

Return values

ptr	New Message

Definition at line 1040 of file mx.c.

{
  if (!m)
    return NULL;
 
  struct Address *p = NULL;
  struct Message *msg = NULL;
 
  if (!m->mx_ops || !m->mx_ops->msg_open_new)
  {
    mutt_debug(LL_DEBUG1, "function unimplemented for mailbox type %d\n", m->type);
    return NULL;
  }
 
  msg = message_new();
  msg->write = true;
 
  if (e)
  {
    msg->flags.flagged = e->flagged;
    msg->flags.replied = e->replied;
    msg->flags.read = e->read;
    msg->flags.draft = (flags & MUTT_SET_DRAFT);
    msg->received = e->received;
  }
 
  if (msg->received == 0)
    msg->received = mutt_date_now();
 
  if (m->mx_ops->msg_open_new(m, msg, e))
  {
    if (m->type == MUTT_MMDF)
      fputs(MMDF_SEP, msg->fp);
 
    if (((m->type == MUTT_MBOX) || (m->type == MUTT_MMDF)) && (flags & MUTT_ADD_FROM))
    {
      if (e)
      {
        p = TAILQ_FIRST(&e->env->return_path);
        if (!p)
          p = TAILQ_FIRST(&e->env->sender);
        if (!p)
          p = TAILQ_FIRST(&e->env->from);
      }
 
      // Use C locale for the date, so that day/month names are in English
      char buf[64] = { 0 };
      mutt_date_localtime_format_locale(buf, sizeof(buf), "%a %b %e %H:%M:%S %Y",
                                        msg->received, NeoMutt->time_c_locale);
      fprintf(msg->fp, "From %s %s\n", p ? buf_string(p->mailbox) : NONULL(Username), buf);
    }
  }
  else
  {
    message_free(&msg);
  }
 
  return msg;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mx_mbox_check()

enum MxStatus mx_mbox_check

(

struct Mailbox *

m

)

Check for new mail - Wrapper for MxOps::mbox_check()

Parameters

m

Mailbox

Return values

enum

MxStatus

Definition at line 1105 of file mx.c.

{
  if (!m || !m->mx_ops)
    return MX_STATUS_ERROR;
 
  const short c_mail_check = cs_subset_number(NeoMutt->sub, "mail_check");
 
  time_t t = mutt_date_now();
  if ((t - m->last_checked) < c_mail_check)
    return MX_STATUS_OK;
 
  m->last_checked = t;
 
  enum MxStatus rc = m->mx_ops->mbox_check(m);
  if ((rc == MX_STATUS_NEW_MAIL) || (rc == MX_STATUS_REOPENED))
  {
    mailbox_changed(m, NT_MAILBOX_INVALID);
  }
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mx_msg_open()

struct Message * mx_msg_open	(	struct Mailbox *	m,
		struct Email *	e
	)

Return a stream pointer for a message.

Parameters

m	Mailbox
e	Email

Return values

ptr	Message
NULL	Error

Definition at line 1134 of file mx.c.

{
  if (!m || !e)
    return NULL;
 
  if (!m->mx_ops || !m->mx_ops->msg_open)
  {
    mutt_debug(LL_DEBUG1, "function not implemented for mailbox type %d\n", m->type);
    return NULL;
  }
 
  struct Message *msg = message_new();
  if (!m->mx_ops->msg_open(m, msg, e))
    message_free(&msg);
 
  return msg;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mx_msg_commit()

int mx_msg_commit	(	struct Mailbox *	m,
		struct Message *	msg
	)

Commit a message to a folder - Wrapper for MxOps::msg_commit()

Parameters

m	Mailbox
msg	Message to commit

Return values

0	Success
-1	Failure

Definition at line 1159 of file mx.c.

{
  if (!m || !m->mx_ops || !m->mx_ops->msg_commit || !msg)
    return -1;
 
  if (!(msg->write && m->append))
  {
    mutt_debug(LL_DEBUG1, "msg->write = %d, m->append = %d\n", msg->write, m->append);
    return -1;
  }
 
  return m->mx_ops->msg_commit(m, msg);
}

Here is the caller graph for this function:

mx_msg_close()

int mx_msg_close	(	struct Mailbox *	m,
		struct Message **	ptr
	)

Close a message.

Parameters

[in]	m	Mailbox
[out]	ptr	Message to close

Return values

0	Success
-1	Failure

Definition at line 1180 of file mx.c.

{
  if (!m || !ptr || !*ptr)
    return 0;
 
  int rc = 0;
  struct Message *msg = *ptr;
 
  if (m->mx_ops && m->mx_ops->msg_close)
    rc = m->mx_ops->msg_close(m, msg);
 
  if (msg->path)
  {
    mutt_debug(LL_DEBUG1, "unlinking %s\n", msg->path);
    unlink(msg->path);
  }
 
  message_free(ptr);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mx_alloc_memory()

void mx_alloc_memory	(	struct Mailbox *	m,
		int	req_size
	)

Create storage for the emails.

Parameters

m	Mailbox
req_size	Space required

Definition at line 1206 of file mx.c.

{
  if ((req_size + 1) <= m->email_max)
    return;
 
  // Step size to increase by
  // Larger mailboxes get a larger step (limited to 1000)
  const int grow = CLAMP(m->email_max, 25, 1000);
 
  // Sanity checks
  req_size = ROUND_UP(req_size + 1, grow);
 
  const size_t s = MAX(sizeof(struct Email *), sizeof(int));
  if ((req_size * s) < (m->email_max * s))
  {
    mutt_error("%s", strerror(ENOMEM));
    mutt_exit(1);
  }
 
  if (m->emails)
  {
    mutt_mem_realloc(&m->emails, req_size * sizeof(struct Email *));
    mutt_mem_realloc(&m->v2r, req_size * sizeof(int));
  }
  else
  {
    m->emails = mutt_mem_calloc(req_size, sizeof(struct Email *));
    m->v2r = mutt_mem_calloc(req_size, sizeof(int));
  }
 
  for (int i = m->email_max; i < req_size; i++)
  {
    m->emails[i] = NULL;
    m->v2r[i] = -1;
  }
 
  m->email_max = req_size;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mx_path_is_empty()

int mx_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 1252 of file mx.c.

{
  if (buf_is_empty(path))
    return -1;
 
  enum MailboxType type = mx_path_probe(buf_string(path));
  const struct MxOps *ops = mx_get_ops(type);
  if (!ops || !ops->path_is_empty)
    return -1;
 
  return ops->path_is_empty(path);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mx_tags_edit()

int mx_tags_edit	(	struct Mailbox *	m,
		const char *	tags,
		struct Buffer *	buf
	)

Start the tag editor of the mailbox.

Parameters

m	Mailbox
tags	Existing tags
buf	Buffer for the results

Return values

-1	Error
0	No valid user input
1	Buffer set

Definition at line 1274 of file mx.c.

{
  if (!m || !buf)
    return -1;
 
  if (m->mx_ops->tags_edit)
    return m->mx_ops->tags_edit(m, tags, buf);
 
  mutt_message(_("Folder doesn't support tagging, aborting"));
  return -1;
}

Here is the caller graph for this function:

mx_tags_commit()

int mx_tags_commit	(	struct Mailbox *	m,
		struct Email *	e,
		const char *	tags
	)

Save tags to the Mailbox - Wrapper for MxOps::tags_commit()

Parameters

m	Mailbox
e	Email
tags	Tags to save

Return values

0	Success
-1	Failure

Definition at line 1294 of file mx.c.

{
  if (!m || !e || !tags)
    return -1;
 
  if (m->mx_ops->tags_commit)
    return m->mx_ops->tags_commit(m, e, tags);
 
  mutt_message(_("Folder doesn't support tagging, aborting"));
  return -1;
}

Here is the caller graph for this function:

mx_tags_is_supported()

bool mx_tags_is_supported

(

struct Mailbox *

m

)

Return true if mailbox support tagging.

Parameters

m

Mailbox

Return values

true	Tagging is supported

Definition at line 1311 of file mx.c.

{
  return m && m->mx_ops->tags_commit && m->mx_ops->tags_edit;
}

Here is the caller graph for this function:

mx_path_probe()

enum MailboxType mx_path_probe

(

const char *

path

)

Find a mailbox that understands a path.

Parameters

path	Path to examine

Return values

enum	MailboxType, e.g. MUTT_IMAP

Definition at line 1321 of file mx.c.

{
  if (!path)
    return MUTT_UNKNOWN;
 
  enum MailboxType rc = MUTT_UNKNOWN;
 
  // First, search the non-local Mailbox types (is_local == false)
  for (const struct MxOps **ops = MxOps; *ops; ops++)
  {
    if ((*ops)->is_local)
      continue;
    rc = (*ops)->path_probe(path, NULL);
    if (rc != MUTT_UNKNOWN)
      return rc;
  }
 
  struct stat st = { 0 };
  if (stat(path, &st) != 0)
  {
    mutt_debug(LL_DEBUG1, "unable to stat %s: %s (errno %d)\n", path, strerror(errno), errno);
    return MUTT_UNKNOWN;
  }
 
  if (S_ISFIFO(st.st_mode))
  {
    mutt_error(_("Can't open %s: it is a pipe"), path);
    return MUTT_UNKNOWN;
  }
 
  // Next, search the local Mailbox types (is_local == true)
  for (const struct MxOps **ops = MxOps; *ops; ops++)
  {
    if (!(*ops)->is_local)
      continue;
    rc = (*ops)->path_probe(path, &st);
    if (rc != MUTT_UNKNOWN)
      return rc;
  }
 
  return rc;
}

Here is the caller graph for this function:

mx_path_canon()

int mx_path_canon	(	struct Buffer *	path,
		const char *	folder,
		enum MailboxType *	type
	)

Canonicalise a mailbox path - Wrapper for MxOps::path_canon()

Definition at line 1367 of file mx.c.

{
  if (buf_is_empty(path))
    return -1;
 
  for (size_t i = 0; i < 3; i++)
  {
    /* Look for !! ! - < > or ^ followed by / or NUL */
    if ((buf_at(path, 0) == '!') && (buf_at(path, 1) == '!'))
    {
      if (((buf_at(path, 2) == '/') || (buf_at(path, 2) == '\0')))
      {
        buf_inline_replace(path, 0, 2, LastFolder);
      }
    }
    else if ((buf_at(path, 0) == '+') || (buf_at(path, 0) == '='))
    {
      size_t folder_len = mutt_str_len(folder);
      if ((folder_len > 0) && (folder[folder_len - 1] != '/'))
      {
        path->data[0] = '/';
        buf_inline_replace(path, 0, 0, folder);
      }
      else
      {
        buf_inline_replace(path, 0, 1, folder);
      }
    }
    else if ((buf_at(path, 1) == '/') || (buf_at(path, 1) == '\0'))
    {
      if (buf_at(path, 0) == '!')
      {
        const char *const c_spool_file = cs_subset_string(NeoMutt->sub, "spool_file");
        buf_inline_replace(path, 0, 1, c_spool_file);
      }
      else if (buf_at(path, 0) == '-')
      {
        buf_inline_replace(path, 0, 1, LastFolder);
      }
      else if (buf_at(path, 0) == '<')
      {
        const char *const c_record = cs_subset_string(NeoMutt->sub, "record");
        buf_inline_replace(path, 0, 1, c_record);
      }
      else if (buf_at(path, 0) == '>')
      {
        const char *const c_mbox = cs_subset_string(NeoMutt->sub, "mbox");
        buf_inline_replace(path, 0, 1, c_mbox);
      }
      else if (buf_at(path, 0) == '^')
      {
        buf_inline_replace(path, 0, 1, CurrentFolder);
      }
      else if (buf_at(path, 0) == '~')
      {
        buf_inline_replace(path, 0, 1, HomeDir);
      }
    }
    else if (buf_at(path, 0) == '@')
    {
      /* elm compatibility, @ expands alias to user name */
      struct AddressList *al = alias_lookup(buf_string(path));
      if (!al || TAILQ_EMPTY(al))
        break;
 
      struct Email *e = email_new();
      e->env = mutt_env_new();
      mutt_addrlist_copy(&e->env->from, al, false);
      mutt_addrlist_copy(&e->env->to, al, false);
      mutt_default_save(path, e);
      email_free(&e);
      break;
    }
    else
    {
      break;
    }
  }
 
  // if (!folder) //XXX - use inherited version, or pass NULL to backend?
  //   return -1;
 
  enum MailboxType type2 = mx_path_probe(buf_string(path));
  if (type)
    *type = type2;
  const struct MxOps *ops = mx_get_ops(type2);
  if (!ops || !ops->path_canon)
    return -1;
 
  if (ops->path_canon(path) < 0)
  {
    mutt_path_canon(path, HomeDir, true);
  }
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mx_path_canon2()

int mx_path_canon2	(	struct Mailbox *	m,
		const char *	folder
	)

Canonicalise the path to realpath.

Parameters

m	Mailbox
folder	Path to canonicalise

Return values

0	Success
-1	Failure

Definition at line 1471 of file mx.c.

{
  if (!m)
    return -1;
 
  struct Buffer *path = buf_pool_get();
 
  if (m->realpath)
    buf_strcpy(path, m->realpath);
  else
    buf_strcpy(path, mailbox_path(m));
 
  int rc = mx_path_canon(path, folder, &m->type);
 
  mutt_str_replace(&m->realpath, buf_string(path));
  buf_pool_release(&path);
 
  if (rc >= 0)
  {
    m->mx_ops = mx_get_ops(m->type);
    buf_strcpy(&m->pathbuf, m->realpath);
  }
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mx_msg_padding_size()

int mx_msg_padding_size

(

struct Mailbox *

m

)

Bytes of padding between messages - Wrapper for MxOps::msg_padding_size()

Parameters

m

Mailbox

Return values

num	Number of bytes of padding

mmdf and mbox add separators, which leads a small discrepancy when computing vsize for a limited view.

Definition at line 1505 of file mx.c.

{
  if (!m || !m->mx_ops || !m->mx_ops->msg_padding_size)
    return 0;
 
  return m->mx_ops->msg_padding_size(m);
}

Here is the caller graph for this function:

mx_ac_find()

struct Account * mx_ac_find

(

struct Mailbox *

m

)

Find the Account owning a Mailbox.

Parameters

m

Mailbox

Return values

ptr	Account
NULL	None found

Definition at line 1519 of file mx.c.

{
  if (!m || !m->mx_ops || !m->realpath)
    return NULL;
 
  struct Account *np = NULL;
  TAILQ_FOREACH(np, &NeoMutt->accounts, entries)
  {
    if (np->type != m->type)
      continue;
 
    if (m->mx_ops->ac_owns_path(np, m->realpath))
      return np;
  }
 
  return NULL;
}

Here is the caller graph for this function:

mx_mbox_find()

struct Mailbox * mx_mbox_find	(	struct Account *	a,
		const char *	path
	)

Find a Mailbox on an Account.

Parameters

a	Account to search
path	Path to find

Return values

ptr

Mailbox

Definition at line 1543 of file mx.c.

{
  if (!a || !path)
    return NULL;
 
  struct MailboxNode *np = NULL;
  struct Url *url_p = NULL;
  struct Url *url_a = NULL;
 
  const bool use_url = (a->type == MUTT_IMAP);
  if (use_url)
  {
    url_p = url_parse(path);
    if (!url_p)
      goto done;
  }
 
  STAILQ_FOREACH(np, &a->mailboxes, entries)
  {
    if (!use_url)
    {
      if (mutt_str_equal(np->mailbox->realpath, path))
        return np->mailbox;
      continue;
    }
 
    url_free(&url_a);
    url_a = url_parse(np->mailbox->realpath);
    if (!url_a)
      continue;
 
    if (!mutt_istr_equal(url_a->host, url_p->host))
      continue;
    if (url_p->user && !mutt_istr_equal(url_a->user, url_p->user))
      continue;
    if (a->type == MUTT_IMAP)
    {
      if (imap_mxcmp(url_a->path, url_p->path) == 0)
        break;
    }
    else
    {
      if (mutt_str_equal(url_a->path, url_p->path))
        break;
    }
  }
 
done:
  url_free(&url_p);
  url_free(&url_a);
 
  if (!np)
    return NULL;
  return np->mailbox;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mx_mbox_find2()

struct Mailbox * mx_mbox_find2

(

const char *

path

)

Find a Mailbox on an Account.

Parameters

path	Path to find

Return values

ptr	Mailbox
NULL	No match

Definition at line 1605 of file mx.c.

{
  if (!path)
    return NULL;
 
  struct Buffer *buf = buf_new(path);
  const char *const c_folder = cs_subset_string(NeoMutt->sub, "folder");
  mx_path_canon(buf, c_folder, NULL);
 
  struct Account *np = NULL;
  TAILQ_FOREACH(np, &NeoMutt->accounts, entries)
  {
    struct Mailbox *m = mx_mbox_find(np, buf_string(buf));
    if (m)
    {
      buf_free(&buf);
      return m;
    }
  }
 
  buf_free(&buf);
  return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mx_path_resolve()

struct Mailbox * mx_path_resolve

(

const char *

path

)

Get a Mailbox for a path.

Parameters

path	Mailbox path

Return values

ptr

Mailbox

If there isn't a Mailbox for the path, one will be created.

Definition at line 1636 of file mx.c.

{
  if (!path)
    return NULL;
 
  struct Mailbox *m = mx_mbox_find2(path);
  if (m)
    return m;
 
  m = mailbox_new();
  buf_strcpy(&m->pathbuf, path);
  const char *const c_folder = cs_subset_string(NeoMutt->sub, "folder");
  mx_path_canon2(m, c_folder);
 
  return m;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mx_mbox_find_by_name_ac()

static struct Mailbox * mx_mbox_find_by_name_ac ( struct Account *  a, const char *  name  )

static

Find a Mailbox with given name under an Account.

Parameters

a	Account to search
name	Name to find

Return values

ptr

Mailbox

Definition at line 1659 of file mx.c.

{
  if (!a || !name)
    return NULL;
 
  struct MailboxNode *np = NULL;
 
  STAILQ_FOREACH(np, &a->mailboxes, entries)
  {
    if (mutt_str_equal(np->mailbox->name, name))
      return np->mailbox;
  }
 
  return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mx_mbox_find_by_name()

static struct Mailbox * mx_mbox_find_by_name ( const char *  name )

static

Find a Mailbox with given name.

Parameters

name	Name to search

Return values

ptr

Mailbox

Definition at line 1680 of file mx.c.

{
  if (!name)
    return NULL;
 
  struct Account *np = NULL;
  TAILQ_FOREACH(np, &NeoMutt->accounts, entries)
  {
    struct Mailbox *m = mx_mbox_find_by_name_ac(np, name);
    if (m)
      return m;
  }
 
  return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mx_resolve()

struct Mailbox * mx_resolve

(

const char *

path_or_name

)

Get a Mailbox from either a path or name.

Parameters

path_or_name

Mailbox path or name

Return values

ptr

Mailbox

Order of resolving:

1. Name
2. Path

Definition at line 1705 of file mx.c.

{
  if (!path_or_name)
    return NULL;
 
  // Order is name first because you can create a Mailbox from
  // a path, but can't from a name. So fallback behavior creates
  // a new Mailbox for us.
  struct Mailbox *m = mx_mbox_find_by_name(path_or_name);
  if (!m)
    m = mx_path_resolve(path_or_name);
 
  return m;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mx_ac_add()

bool mx_ac_add	(	struct Account *	a,
		struct Mailbox *	m
	)

Add a Mailbox to an Account - Wrapper for MxOps::ac_add()

Definition at line 1723 of file mx.c.

{
  if (!a || !m || !m->mx_ops || !m->mx_ops->ac_add)
    return false;
 
  return m->mx_ops->ac_add(a, m) && account_mailbox_add(a, m);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mx_ac_remove()

int mx_ac_remove	(	struct Mailbox *	m,
		bool	keep_account
	)

Remove a Mailbox from an Account and delete Account if empty.

Parameters

m	Mailbox to remove
keep_account	Make sure not to remove the mailbox's account

Return values

0	Success
-1	Error

Note

The mailbox is NOT free'd

Definition at line 1740 of file mx.c.

{
  if (!m || !m->account)
    return -1;
 
  struct Account *a = m->account;
  account_mailbox_remove(m->account, m);
  if (!keep_account && STAILQ_EMPTY(&a->mailboxes))
  {
    neomutt_account_remove(NeoMutt, a);
  }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mx_mbox_check_stats()

enum MxStatus mx_mbox_check_stats	(	struct Mailbox *	m,
		uint8_t	flags
	)

Check the statistics for a mailbox - Wrapper for MxOps::mbox_check_stats()

Note

Emits: NT_MAILBOX_CHANGE

Definition at line 1759 of file mx.c.

{
  if (!m)
    return MX_STATUS_ERROR;
 
  enum MxStatus rc = m->mx_ops->mbox_check_stats(m, flags);
  if (rc != MX_STATUS_ERROR)
  {
    struct EventMailbox ev_m = { m };
    notify_send(m->notify, NT_MAILBOX, NT_MAILBOX_CHANGE, &ev_m);
  }
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mx_save_hcache()

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

Save message to the header cache - Wrapper for MxOps::msg_save_hcache()

Parameters

m	Mailbox
e	Email

Return values

0	Success
-1	Failure

Write a single header out to the header cache.

Definition at line 1783 of file mx.c.

{
  if (!m || !m->mx_ops || !m->mx_ops->msg_save_hcache || !e)
    return 0;
 
  return m->mx_ops->msg_save_hcache(m, e);
}

Here is the caller graph for this function:

mx_type()

enum MailboxType mx_type

(

struct Mailbox *

m

)

Return the type of the Mailbox.

Parameters

m

Mailbox

Return values

enum	MailboxType

Definition at line 1796 of file mx.c.

{
  return m ? m->type : MUTT_MAILBOX_ERROR;
}

Here is the caller graph for this function:

mx_toggle_write()

int mx_toggle_write

(

struct Mailbox *

m

)

Toggle the mailbox's readonly flag.

Parameters

m

Mailbox

Return values

0	Success
-1	Error

Definition at line 1807 of file mx.c.

{
  if (!m)
    return -1;
 
  if (m->readonly)
  {
    mutt_error(_("Can't toggle write on a readonly mailbox"));
    return -1;
  }
 
  if (m->dontwrite)
  {
    m->dontwrite = false;
    mutt_message(_("Changes to folder will be written on folder exit"));
  }
  else
  {
    m->dontwrite = true;
    mutt_message(_("Changes to folder will not be written"));
  }
 
  struct EventMailbox ev_m = { m };
  notify_send(m->notify, NT_MAILBOX, NT_MAILBOX_CHANGE, &ev_m);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

MboxTypeMap

const struct Mapping MboxTypeMap[]

static

Initial value:

= {
  
  { "mbox",    MUTT_MBOX,    },
  { "MMDF",    MUTT_MMDF,    },
  { "MH",      MUTT_MH,      },
  { "Maildir", MUTT_MAILDIR, },
  { NULL, 0, },
  
}

Lookup table of mailbox types.

Definition at line 81 of file mx.c.

MboxTypeDef

const struct EnumDef MboxTypeDef

Initial value:

= {
  "mbox_type",
  4,
  (struct Mapping *) &MboxTypeMap,
}

Data for the $mbox_type enumeration.

Definition at line 92 of file mx.c.

MxOps

const struct MxOps* MxOps[]

static

Initial value:

= {
  
  &MxImapOps,
 
  &MxNotmuchOps,
 
  &MxPopOps,
  &MxNntpOps,
 
  
  &MxMaildirOps,
  &MxMboxOps,
  &MxMhOps,
  &MxMmdfOps,
 
  
  &MxCompOps,
  NULL,
}

All the Mailbox backends.

Definition at line 101 of file mx.c.