mx.h File Reference

API for mailboxes. More...

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

Include dependency graph for mx.h:

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

Go to the source code of this file.

Macros
#define	MUTT_MSG_NO_FLAGS   0
	No flags are set.
#define	MUTT_ADD_FROM   (1 << 0)
	add a From_ line
#define	MUTT_SET_DRAFT   (1 << 1)
	set the message draft flag

Typedefs
typedef uint8_t	MsgOpenFlags
	Flags for mx_msg_open_new(), e.g. MUTT_ADD_FROM.

Functions
enum MxStatus	mx_mbox_check (struct Mailbox *m)
	Check for new mail - Wrapper for MxOps::mbox_check()
enum MxStatus	mx_mbox_check_stats (struct Mailbox *m, uint8_t flags)
	Check the statistics for a mailbox - Wrapper for MxOps::mbox_check_stats()
enum MxStatus	mx_mbox_close (struct Mailbox *m)
	Save changes and close mailbox.
bool	mx_mbox_open (struct Mailbox *m, OpenMailboxFlags flags)
	Open a mailbox and parse it.
enum MxStatus	mx_mbox_sync (struct Mailbox *m)
	Save changes to mailbox.
int	mx_msg_close (struct Mailbox *m, struct Message **ptr)
	Close a message.
int	mx_msg_commit (struct Mailbox *m, struct Message *msg)
	Commit a message to a folder - Wrapper for MxOps::msg_commit()
struct Message *	mx_msg_open_new (struct Mailbox *m, const struct Email *e, MsgOpenFlags flags)
	Open a new message.
struct Message *	mx_msg_open (struct Mailbox *m, struct Email *e)
	Return a stream pointer for a message.
int	mx_msg_padding_size (struct Mailbox *m)
	Bytes of padding between messages - Wrapper for MxOps::msg_padding_size()
int	mx_save_hcache (struct Mailbox *m, struct Email *e)
	Save message to the header cache - Wrapper for MxOps::msg_save_hcache()
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.
enum MailboxType	mx_path_probe (const char *path)
	Find a mailbox that understands a path.
struct Mailbox *	mx_path_resolve (const char *path)
	Get a Mailbox for a path.
struct Mailbox *	mx_resolve (const char *path_or_name)
	Get a Mailbox from either a path or name.
int	mx_tags_commit (struct Mailbox *m, struct Email *e, const char *tags)
	Save tags to the Mailbox - Wrapper for MxOps::tags_commit()
int	mx_tags_edit (struct Mailbox *m, const char *tags, struct Buffer *buf)
	Start the tag editor of the mailbox.
enum MailboxType	mx_type (struct Mailbox *m)
	Return the type of the Mailbox.
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.
bool	mx_mbox_ac_link (struct Mailbox *m)
	Link a Mailbox to an existing or new Account.
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.
int	mx_access (const char *path, int flags)
	Wrapper for access, checks permissions on a given mailbox.
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.
void	mx_fastclose_mailbox (struct Mailbox *m, bool keep_account)
	Free up memory associated with the Mailbox.
const struct MxOps *	mx_get_ops (enum MailboxType type)
	Get mailbox operations.
bool	mx_tags_is_supported (struct Mailbox *m)
	Return true if mailbox support tagging.
int	mx_toggle_write (struct Mailbox *m)
	Toggle the mailbox's readonly flag.

Variables
const struct EnumDef	MboxTypeDef
	Data for the $mbox_type enumeration.

Detailed Description

API for mailboxes.

Authors

• Michael R. Elkins
• Thomas Roessler
• 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 mx.h.

Macro Definition Documentation

MUTT_MSG_NO_FLAGS

#define MUTT_MSG_NO_FLAGS   0

No flags are set.

Definition at line 38 of file mx.h.

MUTT_ADD_FROM

#define MUTT_ADD_FROM   (1 << 0)

add a From_ line

Definition at line 39 of file mx.h.

MUTT_SET_DRAFT

#define MUTT_SET_DRAFT   (1 << 1)

set the message draft flag

Definition at line 40 of file mx.h.

Typedef Documentation

MsgOpenFlags

typedef uint8_t MsgOpenFlags

Flags for mx_msg_open_new(), e.g. MUTT_ADD_FROM.

Definition at line 37 of file mx.h.

Function Documentation

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

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:

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_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

MboxTypeDef

const struct EnumDef MboxTypeDef

extern

Data for the $mbox_type enumeration.

Definition at line 92 of file mx.c.