mutt.h File Reference

Many unsorted constants and some structs. More...

#include "config.h"
#include "mutt.h"
#include "menu/lib.h"
#include <limits.h>
#include <stdbool.h>

Include dependency graph for mutt.h:

Go to the source code of this file.

Macros
#define	PATH_MAX   4096

Enumerations
enum	XdgType { XDG_CONFIG_HOME , XDG_CONFIG_DIRS }
	XDG variable types. More...
enum	EvMessage { EVM_VIEW , EVM_EDIT }
	Edit or View a message. More...
enum	MessageType {   MUTT_ALL = 1 , MUTT_NONE , MUTT_NEW , MUTT_OLD ,   MUTT_REPLIED , MUTT_READ , MUTT_UNREAD , MUTT_DELETE ,   MUTT_UNDELETE , MUTT_PURGE , MUTT_DELETED , MUTT_FLAG ,   MUTT_TAG , MUTT_UNTAG , MUTT_LIMIT , MUTT_EXPIRED ,   MUTT_SUPERSEDED , MUTT_TRASH , MUTT_MT_MAX }
	To set flags or match patterns. More...

Functions
int	mutt_ev_message (struct Mailbox *m, struct EmailArray *ea, enum EvMessage action)
	Edit or view a message.
int	mutt_system (const char *cmd)
	Run an external command.
int	mutt_set_xdg_path (enum XdgType type, struct Buffer *buf)
	Find an XDG path or its fallback.
void	mutt_help (enum MenuType menu)
	Display the Help Page.
void	mutt_set_flag (struct Mailbox *m, struct Email *e, enum MessageType flag, bool bf, bool upd_mbox)
	Set a flag on an email.
void	mutt_signal_init (void)
	Initialise the signal handling.
void	mutt_emails_set_flag (struct Mailbox *m, struct EmailArray *ea, enum MessageType flag, bool bf)
	Set flag on messages.
int	mw_change_flag (struct Mailbox *m, struct EmailArray *ea, bool bf)
	Change the flag on a Message -.
int	mutt_thread_set_flag (struct Mailbox *m, struct Email *e, enum MessageType flag, bool bf, bool subthread)
	Set a flag on an entire thread.
int	mutt_reply_observer (struct NotifyCallback *nc)

Variables
bool	StartupComplete
	When the config has been read.
short	PostCount
	Number of postponed (draft) emails.

Detailed Description

Many unsorted constants and some structs.

Authors

• Michael R. Elkins
• g10 Code GmbH
• 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 mutt.h.

Macro Definition Documentation

PATH_MAX

#define PATH_MAX   4096

Definition at line 49 of file mutt.h.

Enumeration Type Documentation

XdgType

enum XdgType

XDG variable types.

Enumerator
XDG_CONFIG_HOME	XDG home dir: ~/.config.
XDG_CONFIG_DIRS	XDG system dir: /etc/xdg.

Definition at line 65 of file mutt.h.

{
  XDG_CONFIG_HOME, 
  XDG_CONFIG_DIRS, 
};

EvMessage

enum EvMessage

Edit or View a message.

Enumerator
EVM_VIEW	View the message.
EVM_EDIT	Edit the message.

Definition at line 74 of file mutt.h.

{
  EVM_VIEW, 
  EVM_EDIT, 
};

MessageType

enum MessageType

To set flags or match patterns.

See also

mutt_set_flag(), mutt_pattern_func()

Enumerator
MUTT_ALL	All messages.
MUTT_NONE	No messages.
MUTT_NEW	New messages.
MUTT_OLD	Old messages.
MUTT_REPLIED	Messages that have been replied to.
MUTT_READ	Messages that have been read.
MUTT_UNREAD	Unread messages.
MUTT_DELETE	Messages to be deleted.
MUTT_UNDELETE	Messages to be un-deleted.
MUTT_PURGE	Messages to be purged (bypass trash)
MUTT_DELETED	Deleted messages.
MUTT_FLAG	Flagged messages.
MUTT_TAG	Tagged messages.
MUTT_UNTAG	Messages to be un-tagged.
MUTT_LIMIT	Messages in limited view.
MUTT_EXPIRED	Expired messages.
MUTT_SUPERSEDED	Superseded messages.
MUTT_TRASH	Trashed messages.
MUTT_MT_MAX

Definition at line 85 of file mutt.h.

{
  MUTT_ALL = 1,    
  MUTT_NONE,       
  MUTT_NEW,        
  MUTT_OLD,        
  MUTT_REPLIED,    
  MUTT_READ,       
  MUTT_UNREAD,     
  MUTT_DELETE,     
  MUTT_UNDELETE,   
  MUTT_PURGE,      
  MUTT_DELETED,    
  MUTT_FLAG,       
  MUTT_TAG,        
  MUTT_UNTAG,      
  MUTT_LIMIT,      
  MUTT_EXPIRED,    
  MUTT_SUPERSEDED, 
  MUTT_TRASH,      
 
  MUTT_MT_MAX,
};

Function Documentation

mutt_ev_message()

int mutt_ev_message	(	struct Mailbox *	m,
		struct EmailArray *	ea,
		enum EvMessage	action )

Edit or view a message.

Parameters

m	Mailbox
ea	Array of Emails
action	Action to perform, e.g. EVM_EDIT

Return values

1	Message not modified
0	Message edited successfully
-1	Error

Definition at line 282 of file editmsg.c.

{
  struct Email **ep = NULL;
  ARRAY_FOREACH(ep, ea)
  {
    struct Email *e = *ep;
    if (ev_message(action, m, e) == -1)
      return -1;
  }
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_system()

int mutt_system

(

const char *

cmd

)

Run an external command.

Parameters

cmd	Command and arguments

Return values

-1	Error
>=0	Success (command's return code)

Fork and run an external command with arguments.

Note

This function won't return until the command finishes.

Definition at line 51 of file system.c.

{
  int rc = -1;
  struct sigaction act = { 0 };
  struct sigaction oldtstp = { 0 };
  struct sigaction oldcont = { 0 };
  pid_t pid;
 
  if (!cmd || (*cmd == '\0'))
    return 0;
 
  /* must ignore SIGINT and SIGQUIT */
 
  mutt_sig_block_system();
 
  act.sa_handler = SIG_DFL;
/* we want to restart the waitpid() below */
#ifdef SA_RESTART
  act.sa_flags = SA_RESTART;
#endif
  sigemptyset(&act.sa_mask);
  sigaction(SIGTSTP, &act, &oldtstp);
  sigaction(SIGCONT, &act, &oldcont);
 
  pid = fork();
  if (pid == 0)
  {
    act.sa_flags = 0;
 
    mutt_sig_unblock_system(false);
    mutt_sig_reset_child_signals();
 
    execle(EXEC_SHELL, "sh", "-c", cmd, NULL, NeoMutt->env);
    _exit(127); /* execl error */
  }
  else if (pid != -1)
  {
    rc = imap_wait_keep_alive(pid);
  }
 
  sigaction(SIGCONT, &oldcont, NULL);
  sigaction(SIGTSTP, &oldtstp, NULL);
 
  /* reset SIGINT, SIGQUIT and SIGCHLD */
  mutt_sig_unblock_system(true);
 
  rc = (pid != -1) ? (WIFEXITED(rc) ? WEXITSTATUS(rc) : -1) : -1;
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_set_xdg_path()

int mutt_set_xdg_path	(	enum XdgType	type,
		struct Buffer *	buf )

Find an XDG path or its fallback.

Parameters

type	Type of XDG variable, e.g. XDG_CONFIG_HOME
buf	Buffer to save path

Return values

1	An entry was found that actually exists on disk and 0 otherwise

Process an XDG environment variable or its fallback.

Definition at line 871 of file muttlib.c.

{
  const char *xdg_env = mutt_str_getenv(XdgEnvVars[type]);
  char *xdg = xdg_env ? mutt_str_dup(xdg_env) : mutt_str_dup(XdgDefaults[type]);
  char *x = xdg; /* mutt_str_sep() changes xdg, so free x instead later */
  char *token = NULL;
  int rc = 0;
 
  while ((token = mutt_str_sep(&xdg, ":")))
  {
    if (buf_printf(buf, "%s/%s/neomuttrc", token, PACKAGE) < 0)
      continue;
    expand_path(buf, false);
    if (access(buf_string(buf), F_OK) == 0)
    {
      rc = 1;
      break;
    }
 
    if (buf_printf(buf, "%s/%s/Muttrc", token, PACKAGE) < 0)
      continue;
    expand_path(buf, false);
    if (access(buf_string(buf), F_OK) == 0)
    {
      rc = 1;
      break;
    }
  }
 
  FREE(&x);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_help()

void mutt_help

(

enum MenuType

menu

)

Display the Help Page.

Parameters

menu

Menu type

Definition at line 147 of file help.c.

{
  struct BindingInfoArray bia_bind = ARRAY_HEAD_INITIALIZER;
  struct BindingInfoArray bia_macro = ARRAY_HEAD_INITIALIZER;
  struct BindingInfoArray bia_unbound = ARRAY_HEAD_INITIALIZER;
  struct Buffer *banner = NULL;
  struct Buffer *tempfile = NULL;
  struct BindingInfo *bi = NULL;
 
  // ---------------------------------------------------------------------------
  // Gather the data
 
  gather_menu(menu, &bia_bind, &bia_macro, false);
 
  ARRAY_SORT(&bia_bind, binding_sort, NULL);
  ARRAY_SORT(&bia_macro, binding_sort, NULL);
 
  int wb0 = measure_column(&bia_bind, 0);
  int wb1 = measure_column(&bia_bind, 1);
 
  const int wm0 = measure_column(&bia_macro, 0);
 
  gather_unbound(menu, &bia_unbound);
 
  ARRAY_SORT(&bia_unbound, binding_sort, NULL);
  const int wu1 = measure_column(&bia_unbound, 1);
 
  // ---------------------------------------------------------------------------
  // Save the data to a file
 
  tempfile = buf_pool_get();
  buf_mktemp(tempfile);
  FILE *fp = mutt_file_fopen(buf_string(tempfile), "w");
  if (!fp)
  {
    mutt_perror("%s", buf_string(tempfile));
    goto cleanup;
  }
 
  const char *menu_name = NULL;
  ARRAY_FOREACH(bi, &bia_bind)
  {
    if (!bi->a[0])
    {
      menu_name = bi->a[2];
      continue;
    }
 
    if (menu_name)
    {
      if (ARRAY_FOREACH_IDX_bi > 0)
        fprintf(fp, "\n");
 
      fprintf(fp, "%s bindings\n", menu_name);
      fprintf(fp, "\n");
      menu_name = NULL;
    }
 
    // key text description
    fprintf(fp, "%*s  %*s  %s\n", -wb0, bi->a[0], -wb1, bi->a[1], bi->a[2]);
  }
 
  ARRAY_FOREACH(bi, &bia_macro)
  {
    if (!bi->a[0])
    {
      menu_name = bi->a[2];
      continue;
    }
 
    if (menu_name)
    {
      if (ARRAY_FOREACH_IDX_bi > 0)
        fprintf(fp, "\n");
 
      fprintf(fp, "%s macros\n", menu_name);
      fprintf(fp, "\n");
      menu_name = NULL;
    }
 
    if (bi->a[2]) // description
    {
      // key description, macro-text, blank line
      fprintf(fp, "%*s  %s\n", -wm0, bi->a[0], bi->a[2]);
      fprintf(fp, "%s\n", bi->a[1]);
      fprintf(fp, "\n");
    }
    else
    {
      // key macro-text
      fprintf(fp, "%*s  %s\n", -wm0, bi->a[0], bi->a[1]);
    }
  }
  fprintf(fp, "\n");
 
  fprintf(fp, "unbound functions\n");
  fprintf(fp, "\n");
  ARRAY_FOREACH(bi, &bia_unbound)
  {
    // function description
    fprintf(fp, "%*s  %s\n", -wu1, bi->a[1], bi->a[2]);
  }
 
  dump_message_flags(menu, fp);
  mutt_file_fclose(&fp);
 
  // ---------------------------------------------------------------------------
  // Display data
 
  struct PagerData pdata = { 0 };
  struct PagerView pview = { &pdata };
 
  pview.mode = PAGER_MODE_HELP;
  pview.flags = MUTT_PAGER_MARKER | MUTT_PAGER_NOWRAP | MUTT_PAGER_STRIPES;
 
  banner = buf_pool_get();
  menu_name = km_get_menu_name(menu);
  buf_printf(banner, _("Help for %s"), menu_name);
  pdata.fname = buf_string(tempfile);
  pview.banner = buf_string(banner);
  mutt_do_pager(&pview, NULL);
 
cleanup:
 
  ARRAY_FOREACH(bi, &bia_bind)
  {
    FREE(&bi->a[0]);
  }
 
  ARRAY_FOREACH(bi, &bia_macro)
  {
    FREE(&bi->a[0]);
    FREE(&bi->a[1]);
  }
 
  buf_pool_release(&banner);
  buf_pool_release(&tempfile);
  ARRAY_FREE(&bia_bind);
  ARRAY_FREE(&bia_macro);
  ARRAY_FREE(&bia_unbound);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_set_flag()

void mutt_set_flag	(	struct Mailbox *	m,
		struct Email *	e,
		enum MessageType	flag,
		bool	bf,
		bool	upd_mbox )

Set a flag on an email.

Parameters

m	Mailbox
e	Email
flag	Flag to set, e.g. MUTT_DELETE
bf	true: set the flag; false: clear the flag
upd_mbox	true: update the Mailbox

Definition at line 54 of file flags.c.

{
  if (!m || !e)
    return;
 
  bool changed = e->changed;
  int deleted = m->msg_deleted;
  int tagged = m->msg_tagged;
  int flagged = m->msg_flagged;
  int update = false;
 
  if (m->readonly && (flag != MUTT_TAG))
    return; /* don't modify anything if we are read-only */
 
  switch (flag)
  {
    case MUTT_DELETE:
    {
      if (!(m->rights & MUTT_ACL_DELETE))
        return;
 
      if (bf)
      {
        const bool c_flag_safe = cs_subset_bool(NeoMutt->sub, "flag_safe");
        if (!e->deleted && !m->readonly && (!e->flagged || !c_flag_safe))
        {
          e->deleted = true;
          update = true;
          if (upd_mbox)
            m->msg_deleted++;
          /* deleted messages aren't treated as changed elsewhere so that the
           * purge-on-sync option works correctly. This isn't applicable here */
          if (m->type == MUTT_IMAP)
          {
            e->changed = true;
            if (upd_mbox)
              m->changed = true;
          }
        }
      }
      else if (e->deleted)
      {
        e->deleted = false;
        update = true;
        if (upd_mbox)
          m->msg_deleted--;
        /* see my comment above */
        if (m->type == MUTT_IMAP)
        {
          e->changed = true;
          if (upd_mbox)
            m->changed = true;
        }
        /* If the user undeletes a message which is marked as
         * "trash" in the maildir folder on disk, the folder has
         * been changed, and is marked accordingly.  However, we do
         * _not_ mark the message itself changed, because trashing
         * is checked in specific code in the maildir folder
         * driver.  */
        if ((m->type == MUTT_MAILDIR) && upd_mbox && e->trash)
          m->changed = true;
      }
      break;
    }
    case MUTT_PURGE:
    {
      if (!(m->rights & MUTT_ACL_DELETE))
        return;
 
      if (bf)
      {
        if (!e->purge && !m->readonly)
          e->purge = true;
      }
      else if (e->purge)
      {
        e->purge = false;
      }
      break;
    }
    case MUTT_NEW:
    {
      if (!(m->rights & MUTT_ACL_SEEN))
        return;
 
      if (bf)
      {
        if (e->read || e->old)
        {
          update = true;
          e->old = false;
          if (upd_mbox)
            m->msg_new++;
          if (e->read)
          {
            e->read = false;
            if (upd_mbox)
              m->msg_unread++;
          }
          e->changed = true;
          if (upd_mbox)
            m->changed = true;
        }
      }
      else if (!e->read)
      {
        update = true;
        if (!e->old)
          if (upd_mbox)
            m->msg_new--;
        e->read = true;
        if (upd_mbox)
          m->msg_unread--;
        e->changed = true;
        if (upd_mbox)
          m->changed = true;
      }
      break;
    }
    case MUTT_OLD:
    {
      if (!(m->rights & MUTT_ACL_SEEN))
        return;
 
      if (bf)
      {
        if (!e->old)
        {
          update = true;
          e->old = true;
          if (!e->read)
            if (upd_mbox)
              m->msg_new--;
          e->changed = true;
          if (upd_mbox)
            m->changed = true;
        }
      }
      else if (e->old)
      {
        update = true;
        e->old = false;
        if (!e->read)
          if (upd_mbox)
            m->msg_new++;
        e->changed = true;
        if (upd_mbox)
          m->changed = true;
      }
      break;
    }
    case MUTT_READ:
    {
      if (!(m->rights & MUTT_ACL_SEEN))
        return;
 
      if (bf)
      {
        if (!e->read)
        {
          update = true;
          e->read = true;
          if (upd_mbox)
            m->msg_unread--;
          if (!e->old)
            if (upd_mbox)
              m->msg_new--;
          e->changed = true;
          if (upd_mbox)
            m->changed = true;
        }
      }
      else if (e->read)
      {
        update = true;
        e->read = false;
        if (upd_mbox)
          m->msg_unread++;
        if (!e->old)
          if (upd_mbox)
            m->msg_new++;
        e->changed = true;
        if (upd_mbox)
          m->changed = true;
      }
      break;
    }
    case MUTT_REPLIED:
    {
      if (!(m->rights & MUTT_ACL_WRITE))
        return;
 
      if (bf)
      {
        if (!e->replied)
        {
          update = true;
          e->replied = true;
          if (!e->read)
          {
            e->read = true;
            if (upd_mbox)
              m->msg_unread--;
            if (!e->old)
              if (upd_mbox)
                m->msg_new--;
          }
          e->changed = true;
          if (upd_mbox)
            m->changed = true;
        }
      }
      else if (e->replied)
      {
        update = true;
        e->replied = false;
        e->changed = true;
        if (upd_mbox)
          m->changed = true;
      }
      break;
    }
    case MUTT_FLAG:
    {
      if (!(m->rights & MUTT_ACL_WRITE))
        return;
 
      if (bf)
      {
        if (!e->flagged)
        {
          update = true;
          e->flagged = bf;
          if (upd_mbox)
            m->msg_flagged++;
          e->changed = true;
          if (upd_mbox)
            m->changed = true;
        }
      }
      else if (e->flagged)
      {
        update = true;
        e->flagged = false;
        if (upd_mbox)
          m->msg_flagged--;
        e->changed = true;
        if (upd_mbox)
          m->changed = true;
      }
      break;
    }
    case MUTT_TAG:
    {
      if (bf)
      {
        if (!e->tagged)
        {
          update = true;
          e->tagged = true;
          if (upd_mbox)
            m->msg_tagged++;
        }
      }
      else if (e->tagged)
      {
        update = true;
        e->tagged = false;
        if (upd_mbox)
          m->msg_tagged--;
      }
      break;
    }
    default:
    {
      break;
    }
  }
 
  if (update)
  {
    email_set_color(m, e);
    struct EventMailbox ev_m = { m };
    notify_send(m->notify, NT_MAILBOX, NT_MAILBOX_CHANGE, &ev_m);
  }
 
  /* if the message status has changed, we need to invalidate the cached
   * search results so that any future search will match the current status
   * of this message and not what it was at the time it was last searched.  */
  if (e->searched && ((changed != e->changed) || (deleted != m->msg_deleted) ||
                      (tagged != m->msg_tagged) || (flagged != m->msg_flagged)))
  {
    e->searched = false;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_signal_init()

void mutt_signal_init

(

void

)

Initialise the signal handling.

Definition at line 134 of file mutt_signal.c.

{
  mutt_sig_init(curses_signal_handler, curses_exit_handler, curses_segv_handler);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_emails_set_flag()

void mutt_emails_set_flag	(	struct Mailbox *	m,
		struct EmailArray *	ea,
		enum MessageType	flag,
		bool	bf )

Set flag on messages.

Parameters

m	Mailbox
ea	Array of Emails to flag
flag	Flag to set, e.g. MUTT_DELETE
bf	true: set the flag; false: clear the flag

Definition at line 358 of file flags.c.

{
  if (!m || !ea || ARRAY_EMPTY(ea))
    return;
 
  struct Email **ep = NULL;
  ARRAY_FOREACH(ep, ea)
  {
    struct Email *e = *ep;
    mutt_set_flag(m, e, flag, bf, true);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_thread_set_flag()

int mutt_thread_set_flag	(	struct Mailbox *	m,
		struct Email *	e,
		enum MessageType	flag,
		bool	bf,
		bool	subthread )

Set a flag on an entire thread.

Parameters

m	Mailbox
e	Email
flag	Flag to set, e.g. MUTT_DELETE
bf	true: set the flag; false: clear the flag
subthread	If true apply to all of the thread

Return values

0	Success
-1	Failure

Definition at line 382 of file flags.c.

{
  struct MuttThread *start = NULL;
  struct MuttThread *cur = e->thread;
 
  if (!mutt_using_threads())
  {
    mutt_error(_("Threading is not enabled"));
    return -1;
  }
 
  if (!subthread)
    while (cur->parent)
      cur = cur->parent;
 
  start = cur;
 
  if (cur->message && (cur != e->thread))
    mutt_set_flag(m, cur->message, flag, bf, true);
 
  cur = cur->child;
  if (!cur)
    goto done;
 
  while (true)
  {
    if (cur->message && (cur != e->thread))
      mutt_set_flag(m, cur->message, flag, bf, true);
 
    if (cur->child)
    {
      cur = cur->child;
    }
    else if (cur->next)
    {
      cur = cur->next;
    }
    else
    {
      while (!cur->next)
      {
        cur = cur->parent;
        if (cur == start)
          goto done;
      }
      cur = cur->next;
    }
  }
done:
  cur = e->thread;
  if (cur->message)
    mutt_set_flag(m, cur->message, flag, bf, true);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_reply_observer()

int mutt_reply_observer

(

struct NotifyCallback *

nc

)

Variable Documentation

StartupComplete

bool StartupComplete

extern

When the config has been read.

Definition at line 12 of file address.c.

PostCount

short PostCount

extern

Number of postponed (draft) emails.

Definition at line 55 of file postpone.c.