main.c File Reference

NeoMutt Email Client. More...

#include "config.h"
#include <errno.h>
#include <limits.h>
#include <pwd.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/utsname.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 "conn/lib.h"
#include "gui/lib.h"
#include "mutt.h"
#include "attach/lib.h"
#include "browser/lib.h"
#include "cli/lib.h"
#include "color/lib.h"
#include "commands/lib.h"
#include "compose/lib.h"
#include "editor/lib.h"
#include "history/lib.h"
#include "hooks/lib.h"
#include "imap/lib.h"
#include "index/lib.h"
#include "key/lib.h"
#include "ncrypt/lib.h"
#include "nntp/lib.h"
#include "pager/lib.h"
#include "parse/lib.h"
#include "pop/lib.h"
#include "postpone/lib.h"
#include "question/lib.h"
#include "send/lib.h"
#include "sidebar/lib.h"
#include "color/module_data.h"
#include "external.h"
#include "globals.h"
#include "key/module_data.h"
#include "mutt_logging.h"
#include "mutt_mailbox.h"
#include "muttlib.h"
#include "mx.h"
#include "nntp/adata.h"
#include "version.h"
#include <libintl.h>
#include "autocrypt/lib.h"

Go to the source code of this file.

Macros
#define	GNULIB_defined_setlocale

Functions
void	show_cli (enum HelpMode mode, bool use_color)
	Show Instructions on how to run NeoMutt.
static int	execute_commands (struct StringArray *sa)
	Execute a set of NeoMutt commands.
static char *	find_cfg (const char *home, const char *xdg_cfg_home)
	Find a config file.
static char *	getmailname (void)
	Try to retrieve the FQDN from mailname files.
static bool	get_hostname (struct ConfigSet *cs)
	Find the Fully-Qualified Domain Name.
static int	mutt_init (struct ConfigSet *cs, struct Buffer *dlevel, struct Buffer *dfile, bool skip_sys_rc, struct StringArray *user_files, struct StringArray *commands)
	Initialise NeoMutt.
static int	get_elem_queries (struct StringArray *queries, struct HashElemArray *hea)
	Lookup the HashElems for a set of queries.
static void	init_keys (struct NeoMutt *n)
	Initialise the Keybindings.
static int	start_curses (void)
	Start the Curses UI.
static bool	get_user_info (struct ConfigSet *cs)
	Find the user's name, home and shell.
static void	log_translation (void)
	Log the translation being used.
static int	main_timeout_observer (struct NotifyCallback *nc)
	Notification that a timeout has occurred - Implements observer_t -.
static bool	show_help (struct CliHelp *help)
	Show the Help.
static bool	init_logging (struct CliShared *shared, struct ConfigSet *cs)
	Initialise the Logging.
static void	init_nntp (struct Buffer *server, struct ConfigSet *cs)
	Initialise the NNTP config.
static bool	dump_info (struct CliInfo *ci, struct ConfigSet *cs)
	Show config info.
int	main (int argc, char *argv[], char *envp[])
	Start NeoMutt.

Variables
bool	StartupComplete = false
	When the config has been read.
const struct Module	ModuleMain
	Module for the Main library.
const struct Module	ModuleAddress
	Module for the Address library.
const struct Module	ModuleAlias
	Module for the Alias library.
const struct Module	ModuleAttach
	Module for the Attach library.
const struct Module	ModuleAutocrypt
	Module for the Autocrypt library.
const struct Module	ModuleBcache
	Module for the Bcache library.
const struct Module	ModuleBrowser
	Module for the Browser library.
const struct Module	ModuleColor
	Module for the Color library.
const struct Module	ModuleCommands
	Module for the Commands library.
const struct Module	ModuleComplete
	Module for the Complete library.
const struct Module	ModuleCompmbox
	Module for the Compmbox library.
const struct Module	ModuleCompose
	Module for the Compose library.
const struct Module	ModuleCompress
	Module for the Compress library.
const struct Module	ModuleConfig
	Module for the Config library.
const struct Module	ModuleConn
	Module for the Conn library.
const struct Module	ModuleConvert
	Module for the Convert library.
const struct Module	ModuleCore
	Module for the Core library.
const struct Module	ModuleEditor
	Module for the Editor library.
const struct Module	ModuleEmail
	Module for the Email library.
const struct Module	ModuleEnvelope
	Module for the Envelope library.
const struct Module	ModuleExpando
	Module for the Expando library.
const struct Module	ModuleGui
	Module for the Gui library.
const struct Module	ModuleHcache
	Module for the Hcache library.
const struct Module	ModuleHelpbar
	Module for the Helpbar library.
const struct Module	ModuleHistory
	Module for the History library.
const struct Module	ModuleHooks
	Module for the Hooks library.
const struct Module	ModuleImap
	Module for the Imap library.
const struct Module	ModuleIndex
	Module for the Index library.
const struct Module	ModuleKey
	Module for the Key library.
const struct Module	ModuleLua
	Module for the Lua library.
const struct Module	ModuleMaildir
	Module for the Maildir library.
const struct Module	ModuleMbox
	Module for the Mbox library.
const struct Module	ModuleMenu
	Module for the Menu library.
const struct Module	ModuleMh
	Module for the Mh library.
const struct Module	ModuleMutt
	Module for the Mutt library.
const struct Module	ModuleNcrypt
	Module for the Ncrypt library.
const struct Module	ModuleNntp
	Module for the Nntp library.
const struct Module	ModuleNotmuch
	Module for the Notmuch library.
const struct Module	ModulePager
	Module for the Pager library.
const struct Module	ModuleParse
	Module for the Parse library.
const struct Module	ModulePattern
	Module for the Pattern library.
const struct Module	ModulePop
	Module for the Pop library.
const struct Module	ModulePostpone
	Module for the Postpone library.
const struct Module	ModuleProgress
	Module for the Progress library.
const struct Module	ModuleQuestion
	Module for the Question library.
const struct Module	ModuleSend
	Module for the Send library.
const struct Module	ModuleSidebar
	Module for the Sidebar library.
const struct Module	ModuleStore
	Module for the Store library.
static const struct Module *	Modules []
	All the library Modules.

Detailed Description

NeoMutt Email Client.

Authors

• Michael R. Elkins
• Thomas Roessler
• g10 Code GmbH
• Richard Russon
• Pietro Cerutti
• R Primus
• Dennis Schön
• Alejandro Colomar

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

Macro Definition Documentation

GNULIB_defined_setlocale

#define GNULIB_defined_setlocale

Definition at line 88 of file main.c.

Function Documentation

show_cli()

void show_cli	(	enum HelpMode	mode,
		bool	use_color )

Show Instructions on how to run NeoMutt.

Parameters

mode	Details, e.g. HM_SHARED
use_color	Highlight parts of the text

Definition at line 336 of file usage.c.

{
  if (use_color)
    printf("\033[38;5;255mNeoMutt %s\033[0m\n\n", mutt_make_version());
  else
    printf("NeoMutt %s\n\n", mutt_make_version());
 
  switch (mode)
  {
    case HM_NONE:
    {
      show_cli_overview(use_color);
      break;
    }
    case HM_SHARED:
    {
      show_cli_shared(use_color);
      break;
    }
    case HM_HELP:
    {
      show_cli_help(use_color);
      break;
    }
    case HM_INFO:
    {
      show_cli_info(use_color);
      break;
    }
    case HM_SEND:
    {
      show_cli_send(use_color);
      break;
    }
    case HM_TUI:
    {
      show_cli_tui(use_color);
      break;
    }
    case HM_ALL:
    {
      printf("------------------------------------------------------------\n");
      show_cli_shared(use_color);
      printf("\n------------------------------------------------------------\n");
      show_cli_help(use_color);
      printf("\n------------------------------------------------------------\n");
      show_cli_info(use_color);
      printf("\n------------------------------------------------------------\n");
      show_cli_send(use_color);
      printf("\n------------------------------------------------------------\n");
      show_cli_tui(use_color);
      printf("\n------------------------------------------------------------\n");
      break;
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

execute_commands()

static int execute_commands ( struct StringArray * sa )

static

Execute a set of NeoMutt commands.

Parameters

sa	Array of command strings

Return values

0	Success, all the commands succeeded
-1	Error

Definition at line 216 of file main.c.

{
  int rc = 0;
  struct Buffer *line = buf_pool_get();
  struct ParseContext *pc = parse_context_new();
  struct ParseError *pe = parse_error_new();
 
  const char **cp = NULL;
  ARRAY_FOREACH(cp, sa)
  {
    buf_strcpy(line, *cp);
    enum CommandResult rc2 = parse_rc_line(line, pc, pe);
    if (rc2 == MUTT_CMD_ERROR)
      mutt_error(_("Error in command line: %s"), buf_string(pe->message));
    else if (rc2 == MUTT_CMD_WARNING)
      mutt_warning(_("Warning in command line: %s"), buf_string(pe->message));
 
    if ((rc2 == MUTT_CMD_ERROR) || (rc2 == MUTT_CMD_WARNING))
    {
      rc = -1;
      goto done;
    }
  }
 
done:
  buf_pool_release(&line);
  parse_context_free(&pc);
  parse_error_free(&pe);
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

find_cfg()

static char * find_cfg ( const char * home, const char * xdg_cfg_home )

static

Find a config file.

Parameters

home	User's home directory
xdg_cfg_home	XDG home directory

Return values

ptr	Success, first matching directory
NULL	Error, no matching directories

Definition at line 255 of file main.c.

{
  const char *names[] = {
    "neomuttrc",
    "muttrc",
    NULL,
  };
 
  const char *locations[][2] = {
    { xdg_cfg_home, "neomutt/" },
    { xdg_cfg_home, "mutt/" },
    { home, ".neomutt/" },
    { home, ".mutt/" },
    { home, "." },
    { NULL, NULL },
  };
 
  struct Buffer *buf = buf_pool_get();
  char *cfg = NULL;
 
  for (int i = 0; locations[i][0] || locations[i][1]; i++)
  {
    if (!locations[i][0])
      continue;
 
    for (int j = 0; names[j]; j++)
    {
      buf_printf(buf, "%s/%s%s", locations[i][0], locations[i][1], names[j]);
      if (access(buf_string(buf), F_OK) == 0)
      {
        cfg = buf_strdup(buf);
        goto done;
      }
    }
  }
 
done:
  buf_pool_release(&buf);
  return cfg;
}

Here is the call graph for this function:

Here is the caller graph for this function:

getmailname()

static char * getmailname ( void )

static

Try to retrieve the FQDN from mailname files.

Return values

ptr	Heap allocated string with the FQDN
NULL	No valid mailname file could be read

Definition at line 302 of file main.c.

{
  char *mailname = NULL;
  static const char *mn_files[] = { "/etc/mailname", "/etc/mail/mailname" };
 
  for (size_t i = 0; i < countof(mn_files); i++)
  {
    FILE *fp = mutt_file_fopen(mn_files[i], "r");
    if (!fp)
      continue;
 
    size_t len = 0;
    mailname = mutt_file_read_line(NULL, &len, fp, NULL, MUTT_RL_NONE);
    mutt_file_fclose(&fp);
    if (mailname && *mailname)
      break;
 
    FREE(&mailname);
  }
 
  return mailname;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_hostname()

static bool get_hostname ( struct ConfigSet * cs )

static

Find the Fully-Qualified Domain Name.

Parameters

cs	Config Set

Return values

true	Success
false	Error, failed to find any name

Use several methods to try to find the Fully-Qualified domain name of this host. If the user has already configured a hostname, this function will use it.

Definition at line 335 of file main.c.

{
  const char *short_host = NULL;
  struct utsname utsname = { 0 };
 
  const char *const c_hostname = cs_subset_string(NeoMutt->sub, "hostname");
  if (c_hostname)
  {
    short_host = c_hostname;
  }
  else
  {
    /* The call to uname() shouldn't fail, but if it does, the system is horribly
     * broken, and the system's networking configuration is in an unreliable
     * state.  We should bail.  */
    if ((uname(&utsname)) == -1)
    {
      mutt_perror(_("unable to determine nodename via uname()"));
      return false; // TEST09: can't test
    }
 
    short_host = utsname.nodename;
  }
 
  /* some systems report the FQDN instead of just the hostname */
  const char *dot = strchr(short_host, '.');
  if (dot)
    ShortHostname = mutt_strn_dup(short_host, dot - short_host);
  else
    ShortHostname = mutt_str_dup(short_host);
 
  // All the code paths from here alloc memory for the fqdn
  char *fqdn = mutt_str_dup(c_hostname);
  if (!fqdn)
  {
    mutt_debug(LL_DEBUG1, "Setting $hostname\n");
    /* now get FQDN.  Use configured domain first, DNS next, then uname */
#ifdef DOMAIN
    /* we have a compile-time domain name, use that for `$hostname` */
    mutt_str_asprintf(&fqdn, "%s.%s", NONULL(ShortHostname), DOMAIN);
#else
    fqdn = getmailname();
    if (!fqdn)
    {
      struct Buffer *domain = buf_pool_get();
      if (getdnsdomainname(domain) == 0)
      {
        mutt_str_asprintf(&fqdn, "%s.%s", NONULL(ShortHostname), buf_string(domain));
      }
      else
      {
        /* DNS failed, use the nodename.  Whether or not the nodename had a '.'
         * in it, we can use the nodename as the FQDN.  On hosts where DNS is
         * not being used, e.g. small network that relies on hosts files, a
         * short host name is all that is required for SMTP to work correctly.
         * It could be wrong, but we've done the best we can, at this point the
         * onus is on the user to provide the correct hostname if the nodename
         * won't work in their network.  */
        fqdn = mutt_str_dup(utsname.nodename);
      }
      buf_pool_release(&domain);
      mutt_debug(LL_DEBUG1, "Hostname: %s\n", NONULL(fqdn));
    }
#endif
  }
 
  if (fqdn)
  {
    config_str_set_initial(cs, "hostname", fqdn);
    FREE(&fqdn);
  }
 
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_init()

static int mutt_init ( struct ConfigSet * cs, struct Buffer * dlevel, struct Buffer * dfile, bool skip_sys_rc, struct StringArray * user_files, struct StringArray * commands )

static

Initialise NeoMutt.

Parameters

cs	Config Set
dlevel	Command line debug level
dfile	Command line debug file
skip_sys_rc	If true, don't read the system config file
user_files	Array of user config files
commands	Array of config commands to execute

Return values

0	Success
1	Error

Definition at line 421 of file main.c.

{
  bool need_pause = false;
  int rc = 1;
  struct Buffer *buf = buf_pool_get();
  struct ParseContext *pc = parse_context_new();
  struct ParseError *pe = parse_error_new();
  const char **cp = NULL;
 
#ifdef NEOMUTT_DIRECT_COLORS
  /* Test if we run in a terminal which supports direct colours.
   *
   * The user/terminal can indicate their capability independent of the
   * terminfo file by setting the COLORTERM environment variable to "truecolor"
   * or "24bit" (case sensitive).
   *
   * Note: This is to test is less about whether the terminal understands
   * direct color commands but more about whether ncurses believes it can send
   * them to the terminal, e.g. ncurses ignores COLORTERM.
   */
  if (COLORS == 16777216) // 2^24
  {
    /* Ncurses believes the Terminal supports it check the environment variable
     * to respect the user's choice */
    const char *env_colorterm = mutt_str_getenv("COLORTERM");
    if (env_colorterm && (mutt_str_equal(env_colorterm, "truecolor") ||
                          mutt_str_equal(env_colorterm, "24bit")))
    {
      config_str_set_initial(cs, "color_directcolor", "yes");
    }
  }
#endif
 
  /* "$spool_file" precedence: config file, environment */
  const char *p = mutt_str_getenv("MAIL");
  if (!p)
    p = mutt_str_getenv("MAILDIR");
  if (!p)
  {
#ifdef HOMESPOOL
    buf_concat_path(buf, NONULL(NeoMutt->home_dir), MAILPATH);
#else
    buf_concat_path(buf, MAILPATH, NONULL(NeoMutt->username));
#endif
    p = buf_string(buf);
  }
  config_str_set_initial(cs, "spool_file", p);
 
  p = mutt_str_getenv("REPLYTO");
  if (p)
  {
    buf_printf(buf, "Reply-To: %s", p);
    buf_seek(buf, 0);
 
    const struct Command *cmd = command_find_by_id(&NeoMutt->commands, CMD_MY_HEADER);
    ASSERT(cmd);
    parse_my_header(cmd, buf, pc, pe);
  }
 
  p = mutt_str_getenv("EMAIL");
  if (p)
    config_str_set_initial(cs, "from", p);
 
  /* "$mailcap_path" precedence: config file, environment, code */
  struct Buffer *mc = buf_pool_get();
  struct Slist *sl_mc = NULL;
  const char *env_mc = mutt_str_getenv("MAILCAPS");
  if (env_mc)
  {
    sl_mc = slist_parse(env_mc, D_SLIST_SEP_COLON);
  }
  else
  {
    cs_str_initial_get(cs, "mailcap_path", mc);
    sl_mc = slist_parse(buf_string(mc), D_SLIST_SEP_COLON);
    buf_reset(mc);
  }
  slist_to_buffer(sl_mc, mc);
  config_str_set_initial(cs, "mailcap_path", buf_string(mc));
  slist_free(&sl_mc);
  buf_pool_release(&mc);
 
  /* "$tmp_dir" precedence: config file, environment, code */
  const char *env_tmp = mutt_str_getenv("TMPDIR");
  if (env_tmp)
  {
    config_str_set_initial(cs, "tmp_dir", env_tmp);
    config_str_set_initial(cs, "tmp_draft_dir", env_tmp);
  }
 
  /* "$visual", "$editor" precedence: config file, environment, code */
  const char *env_ed = mutt_str_getenv("VISUAL");
  if (!env_ed)
    env_ed = mutt_str_getenv("EDITOR");
  if (!env_ed)
    env_ed = "vi";
  config_str_set_initial(cs, "editor", env_ed);
 
  const char *charset = mutt_ch_get_langinfo_charset();
  config_str_set_initial(cs, "charset", charset);
  mutt_ch_set_charset(charset);
  FREE(&charset);
 
  char name[256] = { 0 };
  const char *c_real_name = cs_subset_string(NeoMutt->sub, "real_name");
  if (!c_real_name)
  {
    struct passwd *pw = getpwuid(getuid());
    if (pw)
    {
      c_real_name = mutt_gecos_name(name, sizeof(name), pw);
    }
  }
  config_str_set_initial(cs, "real_name", c_real_name);
 
  if (ARRAY_EMPTY(user_files))
  {
    const char *xdg_cfg_home = mutt_str_getenv("XDG_CONFIG_HOME");
 
    if (!xdg_cfg_home && NeoMutt->home_dir)
    {
      buf_printf(buf, "%s/.config", NeoMutt->home_dir);
      xdg_cfg_home = buf_string(buf);
    }
 
    char *config = find_cfg(NeoMutt->home_dir, xdg_cfg_home);
    if (config)
    {
      ARRAY_ADD(user_files, config);
    }
  }
  else
  {
    ARRAY_FOREACH(cp, user_files)
    {
      buf_strcpy(buf, *cp);
      FREE(cp);
      expand_path(buf, false);
      ARRAY_SET(user_files, ARRAY_FOREACH_IDX_cp, buf_strdup(buf));
      if (access(buf_string(buf), F_OK))
      {
        mutt_perror("%s", buf_string(buf));
        goto done; // TEST10: neomutt -F missing
      }
    }
  }
 
  ARRAY_FOREACH(cp, user_files)
  {
    if (*cp && !mutt_str_equal(*cp, "/dev/null"))
    {
      cs_str_string_set(cs, "alias_file", *cp, NULL);
      break;
    }
  }
 
  /* Process the global rc file if it exists and the user hasn't explicitly
   * requested not to via "-n".  */
  if (!skip_sys_rc)
  {
    do
    {
      if (mutt_set_xdg_path(XDG_CONFIG_DIRS, buf))
        break;
 
      buf_printf(buf, "%s/neomuttrc", SYSCONFDIR);
      if (access(buf_string(buf), F_OK) == 0)
        break;
 
      buf_printf(buf, "%s/Muttrc", SYSCONFDIR);
      if (access(buf_string(buf), F_OK) == 0)
        break;
 
      buf_printf(buf, "%s/neomuttrc", PKGDATADIR);
      if (access(buf_string(buf), F_OK) == 0)
        break;
 
      buf_printf(buf, "%s/Muttrc", PKGDATADIR);
    } while (false);
 
    if (access(buf_string(buf), F_OK) == 0)
    {
      if (source_rc(buf_string(buf), pc, pe) != 0)
      {
        mutt_error("%s", buf_string(pe->message));
        need_pause = true; // TEST11: neomutt (error in /etc/neomuttrc)
      }
    }
  }
 
  /* Read the user's initialization file.  */
  ARRAY_FOREACH(cp, user_files)
  {
    if (*cp)
    {
      if (source_rc(*cp, pc, pe) != 0)
      {
        mutt_error("%s", buf_string(pe->message));
        need_pause = true; // TEST12: neomutt (error in ~/.neomuttrc)
      }
    }
  }
 
  if (execute_commands(commands) != 0)
    need_pause = true; // TEST13: neomutt -e broken
 
  if (!get_hostname(cs))
    goto done;
 
  /* The command line overrides the config */
  if (!buf_is_empty(dlevel))
    cs_str_reset(cs, "debug_level", NULL);
  if (!buf_is_empty(dfile))
    cs_str_reset(cs, "debug_file", NULL);
 
  if (mutt_log_start() < 0)
  {
    mutt_perror("log file");
    goto done;
  }
 
  if (need_pause && OptGui)
  {
    log_queue_flush(log_disp_terminal);
    if (mutt_any_key_to_continue(NULL) == 'q')
      goto done; // TEST14: neomutt -e broken (press 'q')
  }
 
  const char *const c_tmp_dir = cs_subset_path(NeoMutt->sub, "tmp_dir");
  if (mutt_file_mkdir(c_tmp_dir, S_IRWXU) < 0)
  {
    mutt_error(_("Can't create %s: %s"), c_tmp_dir, strerror(errno));
    goto done;
  }
 
  rc = 0;
 
done:
  parse_context_free(&pc);
  parse_error_free(&pe);
  buf_pool_release(&buf);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_elem_queries()

static int get_elem_queries ( struct StringArray * queries, struct HashElemArray * hea )

static

Lookup the HashElems for a set of queries.

Parameters

[in]	queries	Array of query strings
[out]	hea	Array for Config HashElems

Return values

0	Success, all queries exist
1	Error

Definition at line 674 of file main.c.

{
  int rc = 0;
  const char **cp = NULL;
  ARRAY_FOREACH(cp, queries)
  {
    struct HashElem *he = cs_subset_lookup(NeoMutt->sub, *cp);
    if (!he)
    {
      mutt_warning(_("Unknown option %s"), *cp);
      rc = 1;
      continue;
    }
 
    if (he->type & D_INTERNAL_DEPRECATED)
    {
      mutt_warning(_("Option %s is deprecated"), *cp);
      rc = 1;
      continue;
    }
 
    ARRAY_ADD(hea, he);
  }
 
  return rc; // TEST16: neomutt -Q charset
}

Here is the call graph for this function:

Here is the caller graph for this function:

init_keys()

static void init_keys ( struct NeoMutt * n )

static

Initialise the Keybindings.

Definition at line 704 of file main.c.

{
  struct SubMenu *sm_generic = generic_init_keys(n);
 
  alias_init_keys(n, sm_generic);
  attach_init_keys(n, sm_generic);
#ifdef USE_AUTOCRYPT
  autocrypt_init_keys(n, sm_generic);
#endif
  browser_init_keys(n, sm_generic);
  compose_init_keys(n, sm_generic);
  editor_init_keys(n, sm_generic);
  sidebar_init_keys(n, sm_generic);
  index_init_keys(n, sm_generic);
  pager_init_keys(n, sm_generic);
  pgp_init_keys(n, sm_generic);
  postponed_init_keys(n, sm_generic);
 
  km_sort();
}

Here is the call graph for this function:

Here is the caller graph for this function:

start_curses()

static int start_curses ( void )

static

Start the Curses UI.

Return values

0	Success
1	Failure

Definition at line 730 of file main.c.

{
  /* should come before initscr() so that ncurses 4.2 doesn't try to install
   * its own SIGWINCH handler */
  mutt_signal_init();
 
  if (!initscr())
  {
    mutt_error(_("Error initializing terminal"));
    return 1;
  }
 
  struct ColorModuleData *color_mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_COLOR);
  colors_init(color_mod_data);
  keypad(stdscr, true);
  cbreak();
  noecho();
  nonl();
  typeahead(-1); /* simulate smooth scrolling */
  meta(stdscr, true);
  struct KeyModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_KEY);
  ext_keys_init(mod_data->key_names);
 
  /* Now that curses is set up, we drop back to normal screen mode.
   * This simplifies displaying error messages to the user.
   * The first call to refresh() will swap us back to curses screen mode. */
  endwin();
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_user_info()

static bool get_user_info ( struct ConfigSet * cs )

static

Find the user's name, home and shell.

Parameters

cs	Config Set

Return values

true

Success

Find the login name, real name, home directory and shell.

Definition at line 767 of file main.c.

{
  const char *shell = mutt_str_getenv("SHELL");
 
  /* Get some information about the user */
  struct passwd *pw = getpwuid(getuid());
  if (pw)
  {
    if (!NeoMutt->username)
      NeoMutt->username = mutt_str_dup(pw->pw_name);
    if (!NeoMutt->home_dir)
      NeoMutt->home_dir = mutt_str_dup(pw->pw_dir);
    if (!shell)
      shell = pw->pw_shell;
  }
 
  if (!NeoMutt->username)
  {
    mutt_error(_("unable to determine username"));
    return false; // TEST05: neomutt (unset $USER, delete user from /etc/passwd)
  }
 
  if (!NeoMutt->home_dir)
  {
    mutt_error(_("unable to determine home directory"));
    return false; // TEST06: neomutt (unset $HOME, delete user from /etc/passwd)
  }
 
  if (shell)
    config_str_set_initial(cs, "shell", shell);
 
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

log_translation()

static void log_translation ( void )

static

Log the translation being used.

Read the header info from the translation file.

Note

Call bindtextdomain() first

Definition at line 808 of file main.c.

{
  const char *header = ""; // Do not merge these two lines
  header = _(header);      // otherwise the .po files will end up badly ordered
  const char *label = "Language:"; // the start of the lookup/needle
  const char *lang = mutt_istr_find(header, label);
  int len = 64;
  if (lang)
  {
    lang += strlen(label); // skip label
    SKIPWS(lang);
    const char *nl = strchr(lang, '\n');
    if (nl)
      len = (nl - lang);
  }
  else
  {
    lang = "NONE";
  }
 
  mutt_debug(LL_DEBUG1, "Translation: %.*s\n", len, lang);
}

Here is the call graph for this function:

Here is the caller graph for this function:

show_help()

static bool show_help ( struct CliHelp * help )

static

Show the Help.

Parameters

help	Command Line Options

Return values

true	Success, continue

Definition at line 868 of file main.c.

{
  if (!help->is_set)
    return true;
 
  log_queue_flush(log_disp_terminal);
 
  const bool tty = isatty(STDOUT_FILENO);
 
  if (help->help)
  {
    show_cli(help->mode, tty);
  }
  else if (help->license)
  {
    print_copyright();
  }
  else
  {
    print_version(stdout, tty);
  }
 
  return false; // Stop
}

Here is the call graph for this function:

Here is the caller graph for this function:

init_logging()

static bool init_logging ( struct CliShared * shared, struct ConfigSet * cs )

static

Initialise the Logging.

Parameters

shared	Shared Command line Options
cs	Config Set

Return values

true

Success

Definition at line 899 of file main.c.

{
  if (!shared->is_set)
    return true;
 
  if (!buf_is_empty(&shared->log_file))
    config_str_set_initial(cs, "debug_file", buf_string(&shared->log_file));
 
  if (!buf_is_empty(&shared->log_level))
  {
    const char *dlevel = buf_string(&shared->log_level);
    short num = 0;
    if (!mutt_str_atos_full(dlevel, &num) || (num < LL_MESSAGE) || (num >= LL_MAX))
    {
      mutt_error(_("Error: value '%s' is invalid for -d"), dlevel);
      return false;
    }
 
    config_str_set_initial(cs, "debug_level", dlevel);
  }
 
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

init_nntp()

static void init_nntp ( struct Buffer * server, struct ConfigSet * cs )

static

Initialise the NNTP config.

Parameters

server	NNTP Server to use
cs	Config Set

Definition at line 928 of file main.c.

{
  const char *cli_nntp = NULL;
  if (!buf_is_empty(server))
    cli_nntp = buf_string(server);
 
  /* "$news_server" precedence: command line, config file, environment, system file */
  if (!cli_nntp)
    cli_nntp = cs_subset_string(NeoMutt->sub, "news_server");
 
  if (!cli_nntp)
    cli_nntp = mutt_str_getenv("NNTPSERVER");
 
  if (!cli_nntp)
  {
    char buf[1024] = { 0 };
    cli_nntp = mutt_file_read_keyword(SYSCONFDIR "/nntpserver", buf, sizeof(buf));
  }
 
  if (cli_nntp)
    config_str_set_initial(cs, "news_server", cli_nntp);
}

Here is the call graph for this function:

Here is the caller graph for this function:

dump_info()

static bool dump_info ( struct CliInfo * ci, struct ConfigSet * cs )

static

Show config info.

Parameters

ci	Command line Options
cs	Config Set

Return values

true

Success

Definition at line 957 of file main.c.

{
  if (!ci->is_set)
    return true;
 
  if (ci->dump_config || !ARRAY_EMPTY(&ci->queries))
  {
    const bool tty = isatty(STDOUT_FILENO);
 
    ConfigDumpFlags cdflags = CS_DUMP_NONE;
    if (tty)
      cdflags |= CS_DUMP_LINK_DOCS;
    if (ci->hide_sensitive)
      cdflags |= CS_DUMP_HIDE_SENSITIVE;
    if (ci->show_help)
      cdflags |= CS_DUMP_SHOW_DOCS;
 
    struct HashElemArray hea = ARRAY_HEAD_INITIALIZER;
    if (ci->dump_config)
    {
      enum GetElemListFlags gel_flags = ci->dump_changed ? GEL_CHANGED_CONFIG : GEL_ALL_CONFIG;
      hea = get_elem_list(cs, gel_flags);
    }
    else
    {
      get_elem_queries(&ci->queries, &hea);
    }
 
    dump_config(cs, &hea, cdflags, stdout);
    ARRAY_FREE(&hea);
  }
  else if (!ARRAY_EMPTY(&ci->alias_queries))
  {
    const char **cp = NULL;
    ARRAY_FOREACH(cp, &ci->alias_queries)
    {
      struct AddressList *al = alias_lookup(*cp);
      if (al)
      {
        /* output in machine-readable form */
        mutt_addrlist_to_intl(al, NULL);
        struct Buffer *buf = buf_pool_get();
        mutt_addrlist_write(al, buf, false);
        printf("%s\n", buf_string(buf));
        buf_pool_release(&buf);
      }
      else
      {
        printf("%s\n", NONULL(*cp)); // TEST19: neomutt -A unknown
      }
    }
  }
 
  return false; // Stop
}

Here is the call graph for this function:

Here is the caller graph for this function:

main()

int main	(	int	argc,
		char *	argv[],
		char *	envp[] )

Start NeoMutt.

Parameters

argc	Number of command line arguments
argv	List of command line arguments
envp	Copy of the environment

Return values

0	Success
1	Error

Definition at line 1021 of file main.c.

{
  MuttLogger = log_disp_queue;
 
  struct Email *e = NULL;
  SendFlags sendflags = SEND_NONE;
  int rc = 1;
  bool repeat_error = false;
  struct Buffer *expanded_infile = buf_pool_get();
  struct Buffer *tempfile = buf_pool_get();
  struct ConfigSet *cs = NULL;
  struct CommandLine *cli = command_line_new();
 
  /* sanity check against stupid administrators */
  if (getegid() != getgid())
  {
    mutt_error("%s: I don't want to run with privileges!", (argc != 0) ? argv[0] : "neomutt");
    goto done; // TEST01: neomutt (as root, chgrp mail neomutt; chmod +s neomutt)
  }
 
  OptGui = true;
 
  NeoMutt = neomutt_new();
  if (!neomutt_init(NeoMutt, envp, Modules))
    goto done;
 
  cli_parse(argc, argv, cli);
 
  if (!show_help(&cli->help))
  {
    rc = 0;
    goto done;
  }
 
  init_keys(NeoMutt);
 
#ifdef USE_DEBUG_NOTIFY
  notify_observer_add(NeoMutt->notify, NT_ALL, debug_all_observer, NULL);
#endif
 
  cs = NeoMutt->sub->cs;
  if (!get_user_info(cs))
    goto done;
 
  if (!init_logging(&cli->shared, cs))
    goto done;
 
  mutt_log_prep();
  log_translation();
 
  /* Check for a batch send. */
  if (!isatty(STDIN_FILENO) || !ARRAY_EMPTY(&cli->info.queries) ||
      !ARRAY_EMPTY(&cli->info.alias_queries) || cli->info.dump_config)
  {
    OptGui = false;
    sendflags |= SEND_BATCH;
    MuttLogger = log_disp_terminal;
    log_queue_flush(log_disp_terminal);
  }
 
  /* Check to make sure stdout is available in curses mode. */
  if (OptGui && !isatty(STDOUT_FILENO))
    goto done;
 
  /* This must come before mutt_init() because curses needs to be started
   * before calling the init_pair() function to set the color scheme.  */
  if (OptGui)
  {
    int crc = start_curses();
    if (crc != 0)
      goto done; // TEST08: can't test -- fake term?
  }
 
  /* Always create the mutt_windows because batch mode has some shared code
   * paths that end up referencing them. */
  struct GuiModuleData *gui_mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_GUI);
  rootwin_new(gui_mod_data);
 
  /* set defaults and read init files */
  int rc2 = mutt_init(cs, &cli->shared.log_level, &cli->shared.log_file,
                      cli->shared.disable_system, &cli->shared.user_files,
                      &cli->shared.commands);
  if (rc2 != 0)
    goto done;
 
  if (OptGui)
    neomutt_gui_init(NeoMutt);
 
  init_nntp(&cli->tui.nntp_server, cs);
 
  /* Initialize crypto backends.  */
  crypt_init();
 
  if (!buf_is_empty(&cli->shared.mbox_type) &&
      !config_str_set_initial(cs, "mbox_type", buf_string(&cli->shared.mbox_type)))
  {
    goto done;
  }
 
  if (!dump_info(&cli->info, cs))
  {
    rc = 0;
    goto done;
  }
 
#ifdef USE_AUTOCRYPT
  /* Initialize autocrypt after curses messages are working,
   * because of the initial account setup screens. */
  const bool c_autocrypt = cs_subset_bool(NeoMutt->sub, "autocrypt");
  if (c_autocrypt)
    (void) mutt_autocrypt_init(!(sendflags & SEND_BATCH));
#endif
 
  /* Create the `$folder` directory if it doesn't exist. */
  const char *const c_folder = cs_subset_string(NeoMutt->sub, "folder");
  if (OptGui && c_folder)
  {
    struct stat st = { 0 };
    struct Buffer *fpath = buf_pool_get();
 
    buf_strcpy(fpath, c_folder);
    expand_path(fpath, false);
    bool skip = false;
    /* we're not connected yet - skip mail folder creation */
    skip |= (imap_path_probe(buf_string(fpath), NULL) == MUTT_IMAP);
    skip |= (pop_path_probe(buf_string(fpath), NULL) == MUTT_POP);
    skip |= (nntp_path_probe(buf_string(fpath), NULL) == MUTT_NNTP);
    if (!skip && (stat(buf_string(fpath), &st) == -1) && (errno == ENOENT))
    {
      char msg2[256] = { 0 };
      snprintf(msg2, sizeof(msg2), _("%s does not exist. Create it?"), c_folder);
      if (query_yesorno(msg2, MUTT_YES) == MUTT_YES)
      {
        if ((mkdir(buf_string(fpath), 0700) == -1) && (errno != EEXIST))
          mutt_error(_("Can't create %s: %s"), c_folder, strerror(errno)); // TEST21: neomutt -n -F /dev/null (and ~/Mail doesn't exist)
      }
    }
    buf_pool_release(&fpath);
  }
 
  StartupComplete = true;
 
  notify_observer_add(NeoMutt->sub->notify, NT_CONFIG, main_hist_observer, NULL);
  notify_observer_add(NeoMutt->sub->notify, NT_CONFIG, main_log_observer, NULL);
  notify_observer_add(NeoMutt->notify, NT_TIMEOUT, main_timeout_observer, NULL);
 
  if (cli->tui.start_postponed)
  {
    if (OptGui)
      mutt_flushinp();
    if (mutt_send_message(SEND_POSTPONED, NULL, NULL, NULL, NULL, NeoMutt->sub) == 0)
      rc = 0;
    // TEST23: neomutt -p (postponed message, cancel)
    // TEST24: neomutt -p (no postponed message)
    log_queue_empty();
    repeat_error = true;
    goto done;
  }
  else if (cli->send.is_set)
  {
    FILE *fp_in = NULL;
    FILE *fp_out = NULL;
    const char *infile = NULL;
    char *bodytext = NULL;
    const char *bodyfile = NULL;
    int rv = 0;
 
    if (OptGui)
      mutt_flushinp();
 
    if (cli->send.use_crypto)
      sendflags |= SEND_CLI_CRYPTO;
 
    e = email_new();
    e->env = mutt_env_new();
 
    const char **cp = NULL;
    ARRAY_FOREACH(cp, &cli->send.bcc_list)
    {
      mutt_addrlist_parse(&e->env->bcc, *cp);
    }
 
    ARRAY_FOREACH(cp, &cli->send.cc_list)
    {
      mutt_addrlist_parse(&e->env->cc, *cp);
    }
 
    ARRAY_FOREACH(cp, &cli->send.addresses)
    {
      if (url_check_scheme(*cp) == U_MAILTO)
      {
        if (!mutt_parse_mailto(e->env, &bodytext, *cp))
        {
          mutt_error(_("Failed to parse mailto: link"));
          email_free(&e);
          goto done; // TEST25: neomutt mailto:?
        }
      }
      else
      {
        mutt_addrlist_parse(&e->env->to, *cp);
      }
    }
 
    const bool c_auto_edit = cs_subset_bool(NeoMutt->sub, "auto_edit");
    if (buf_is_empty(&cli->send.draft_file) && c_auto_edit &&
        TAILQ_EMPTY(&e->env->to) && TAILQ_EMPTY(&e->env->cc))
    {
      mutt_error(_("No recipients specified"));
      email_free(&e);
      goto done; // TEST26: neomutt -s test (with auto_edit=yes)
    }
 
    if (!buf_is_empty(&cli->send.subject))
    {
      /* prevent header injection */
      mutt_filter_commandline_header_value(cli->send.subject.data);
      mutt_env_set_subject(e->env, buf_string(&cli->send.subject));
    }
 
    if (!buf_is_empty(&cli->send.draft_file))
    {
      infile = buf_string(&cli->send.draft_file);
    }
    else if (!buf_is_empty(&cli->send.include_file))
    {
      infile = buf_string(&cli->send.include_file);
    }
    else
    {
      cli->send.edit_infile = false;
    }
 
    if (infile || bodytext)
    {
      /* Prepare fp_in and expanded_infile. */
      if (infile)
      {
        if (mutt_str_equal("-", infile))
        {
          if (cli->send.edit_infile)
          {
            mutt_error(_("Can't use -E flag with stdin"));
            email_free(&e);
            goto done; // TEST27: neomutt -E -H -
          }
          fp_in = stdin;
        }
        else
        {
          buf_strcpy(expanded_infile, infile);
          expand_path(expanded_infile, false);
          fp_in = mutt_file_fopen(buf_string(expanded_infile), "r");
          if (!fp_in)
          {
            mutt_perror("%s", buf_string(expanded_infile));
            email_free(&e);
            goto done; // TEST28: neomutt -E -H missing
          }
        }
      }
 
      if (cli->send.edit_infile)
      {
        /* If editing the infile, keep it around afterwards so
         * it doesn't get unlinked, and we can rebuild the draft_file */
        sendflags |= SEND_NO_FREE_HEADER;
      }
      else
      {
        /* Copy input to a tempfile, and re-point fp_in to the tempfile.
         * Note: stdin is always copied to a tempfile, ensuring draft_file
         * can stat and get the correct st_size below.  */
        buf_mktemp_draft(tempfile);
 
        fp_out = mutt_file_fopen(buf_string(tempfile), "w");
        if (!fp_out)
        {
          mutt_file_fclose(&fp_in);
          mutt_perror("%s", buf_string(tempfile));
          email_free(&e);
          goto done; // TEST29: neomutt -H existing-file (where tmpdir=/path/to/FILE blocking tmpdir)
        }
        if (fp_in)
        {
          mutt_file_copy_stream(fp_in, fp_out);
          if (fp_in == stdin)
            sendflags |= SEND_CONSUMED_STDIN;
          else
            mutt_file_fclose(&fp_in);
        }
        else if (bodytext)
        {
          fputs(bodytext, fp_out);
        }
        mutt_file_fclose(&fp_out);
 
        fp_in = mutt_file_fopen(buf_string(tempfile), "r");
        if (!fp_in)
        {
          mutt_perror("%s", buf_string(tempfile));
          email_free(&e);
          goto done; // TEST30: can't test
        }
      }
 
      /* Parse the draft_file into the full Email/Body structure.
       * Set SEND_DRAFT_FILE so mutt_send_message doesn't overwrite
       * our e->body.  */
      if (!buf_is_empty(&cli->send.draft_file))
      {
        struct Envelope *opts_env = e->env;
        struct stat st = { 0 };
 
        sendflags |= SEND_DRAFT_FILE;
 
        /* Set up a tmp Email with just enough information so that
         * mutt_prepare_template() can parse the message in fp_in.  */
        struct Email *e_tmp = email_new();
        e_tmp->offset = 0;
        e_tmp->body = mutt_body_new();
        if (fstat(fileno(fp_in), &st) != 0)
        {
          mutt_perror("%s", buf_string(&cli->send.draft_file));
          email_free(&e);
          email_free(&e_tmp);
          goto done; // TEST31: can't test
        }
        e_tmp->body->length = st.st_size;
 
        if (mutt_prepare_template(fp_in, NULL, e, e_tmp, false) < 0)
        {
          mutt_error(_("Can't parse message template: %s"),
                     buf_string(&cli->send.draft_file));
          email_free(&e);
          email_free(&e_tmp);
          goto done;
        }
 
        /* Scan for neomutt header to set `$resume_draft_files` */
        struct ListNode *tmp = NULL;
        const bool c_resume_edited_draft_files = cs_subset_bool(NeoMutt->sub, "resume_edited_draft_files");
        struct ListNode *np = NULL;
        STAILQ_FOREACH_SAFE(np, &e->env->userhdrs, entries, tmp)
        {
          if (mutt_istr_startswith(np->data, "X-Mutt-Resume-Draft:"))
          {
            if (c_resume_edited_draft_files)
              cs_str_native_set(cs, "resume_draft_files", true, NULL);
 
            STAILQ_REMOVE(&e->env->userhdrs, np, ListNode, entries);
            FREE(&np->data);
            FREE(&np);
          }
        }
 
        mutt_addrlist_copy(&e->env->to, &opts_env->to, false);
        mutt_addrlist_copy(&e->env->cc, &opts_env->cc, false);
        mutt_addrlist_copy(&e->env->bcc, &opts_env->bcc, false);
        if (opts_env->subject)
          mutt_env_set_subject(e->env, opts_env->subject);
 
        mutt_env_free(&opts_env);
        email_free(&e_tmp);
      }
      else if (cli->send.edit_infile)
      {
        /* Editing the include_file: pass it directly in.
         * Note that SEND_NO_FREE_HEADER is set above so it isn't unlinked.  */
        bodyfile = buf_string(expanded_infile);
      }
      else
      {
        // For bodytext and unedited include_file: use the tempfile.
        bodyfile = buf_string(tempfile);
      }
 
      mutt_file_fclose(&fp_in);
    }
 
    FREE(&bodytext);
 
    if (!ARRAY_EMPTY(&cli->send.attach))
    {
      struct Body *b = e->body;
 
      while (b && b->next)
        b = b->next;
 
      ARRAY_FOREACH(cp, &cli->send.attach)
      {
        if (b)
        {
          b->next = mutt_make_file_attach(*cp, NeoMutt->sub);
          b = b->next;
        }
        else
        {
          b = mutt_make_file_attach(*cp, NeoMutt->sub);
          e->body = b;
        }
        if (!b)
        {
          mutt_error(_("%s: unable to attach file"), *cp);
          email_free(&e);
          goto done; // TEST32: neomutt john@example.com -a missing
        }
      }
    }
 
    rv = mutt_send_message(sendflags, e, bodyfile, NULL, NULL, NeoMutt->sub);
    /* We WANT the "Mail sent." and any possible, later error */
    log_queue_empty();
    if (ErrorBufMessage)
      mutt_message("%s", ErrorBuf);
 
    if (cli->send.edit_infile)
    {
      if (!buf_is_empty(&cli->send.draft_file))
      {
        if (truncate(buf_string(expanded_infile), 0) == -1)
        {
          mutt_perror("%s", buf_string(expanded_infile));
          email_free(&e);
          goto done; // TEST33: neomutt -H read-only -s test john@example.com -E
        }
        fp_out = mutt_file_fopen(buf_string(expanded_infile), "a");
        if (!fp_out)
        {
          mutt_perror("%s", buf_string(expanded_infile));
          email_free(&e);
          goto done; // TEST34: can't test
        }
 
        /* If the message was sent or postponed, these will already
         * have been done.  */
        if (rv < 0)
        {
          if (e->body->next)
            e->body = mutt_make_multipart(e->body);
          mutt_encode_descriptions(e->body, true, NeoMutt->sub);
          mutt_prepare_envelope(e->env, false, NeoMutt->sub);
          mutt_env_to_intl(e->env, NULL, NULL);
        }
 
        const bool c_crypt_protected_headers_read = cs_subset_bool(NeoMutt->sub, "crypt_protected_headers_read");
        mutt_rfc822_write_header(fp_out, e->env, e->body, MUTT_WRITE_HEADER_POSTPONE, false,
                                 c_crypt_protected_headers_read &&
                                     mutt_should_hide_protected_subject(e),
                                 NeoMutt->sub);
        const bool c_resume_edited_draft_files = cs_subset_bool(NeoMutt->sub, "resume_edited_draft_files");
        if (c_resume_edited_draft_files)
          fprintf(fp_out, "X-Mutt-Resume-Draft: 1\n");
        fputc('\n', fp_out);
        if ((mutt_write_mime_body(e->body, fp_out, NeoMutt->sub) == -1))
        {
          mutt_file_fclose(&fp_out);
          email_free(&e);
          goto done; // TEST35: can't test
        }
        mutt_file_fclose(&fp_out);
      }
 
      email_free(&e);
    }
 
    /* !edit_infile && draft_file will leave the tempfile around */
    if (!buf_is_empty(tempfile))
      unlink(buf_string(tempfile));
 
    rootwin_cleanup(gui_mod_data);
 
    if (rv != 0)
      goto done; // TEST36: neomutt -H existing -s test john@example.com -E (cancel sending)
  }
  else if (sendflags & SEND_BATCH)
  {
    /* This guards against invoking `neomutt < /dev/null` and accidentally
     * sending an email due to a my-header or other setting.  */
    mutt_error(_("No recipients specified"));
    goto done;
  }
  else
  {
    struct Buffer *folder = &cli->tui.folder;
    bool explicit_folder = !buf_is_empty(folder);
 
    if (cli->tui.start_new_mail)
    {
      const bool c_imap_passive = cs_subset_bool(NeoMutt->sub, "imap_passive");
      cs_subset_str_native_set(NeoMutt->sub, "imap_passive", false, NULL);
      const CheckStatsFlags csflags = MUTT_MAILBOX_CHECK_IMMEDIATE;
      if (mutt_mailbox_check(NULL, csflags) == 0)
      {
        mutt_message(_("No mailbox with new mail"));
        goto done; // TEST37: neomutt -Z (no new mail)
      }
      buf_reset(folder);
      mutt_mailbox_next(NULL, folder);
      cs_subset_str_native_set(NeoMutt->sub, "imap_passive", c_imap_passive, NULL);
    }
    else if (cli->tui.start_nntp || cli->tui.start_browser)
    {
      if (cli->tui.start_nntp)
      {
        struct NntpModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_NNTP);
        const char *const c_news_server = cs_subset_string(NeoMutt->sub, "news_server");
        OptNews = true;
        mod_data->current_news_srv = nntp_select_server(NULL, c_news_server, false);
        if (!mod_data->current_news_srv)
          goto done; // TEST38: neomutt -G (unset news_server)
      }
      else if (ARRAY_EMPTY(&NeoMutt->accounts))
      {
        mutt_error(_("No incoming mailboxes defined"));
        goto done; // TEST39: neomutt -n -F /dev/null -y
      }
      buf_reset(folder);
      dlg_browser(folder, MUTT_SEL_FOLDER | MUTT_SEL_MAILBOX, NULL, NULL, NULL);
      if (buf_is_empty(folder))
      {
        rc = 0;
        goto done; // TEST40: neomutt -y (quit selection)
      }
    }
 
    if (buf_is_empty(folder))
    {
      const char *const c_spool_file = cs_subset_string(NeoMutt->sub, "spool_file");
      if (c_spool_file)
      {
        // Check if `$spool_file` corresponds a mailboxes' description.
        struct Mailbox *m_desc = mailbox_find_name(c_spool_file);
        if (m_desc)
          buf_strcpy(folder, m_desc->realpath);
        else
          buf_strcpy(folder, c_spool_file);
      }
      else if (c_folder)
      {
        buf_strcpy(folder, c_folder);
      }
      /* else no folder */
    }
 
    if (OptNews)
    {
      struct NntpModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_NNTP);
      OptNews = false;
      buf_alloc(folder, PATH_MAX);
      nntp_expand_path(folder->data, folder->dsize,
                       &mod_data->current_news_srv->conn->account);
    }
    else
    {
      expand_path(folder, false);
    }
 
    mutt_str_replace(&CurrentFolder, buf_string(folder));
    mutt_str_replace(&LastFolder, buf_string(folder));
 
    if (cli->tui.start_any_mail || cli->tui.start_new_mail)
    {
      /* check to see if there are any messages in the folder */
      switch (mx_path_is_empty(folder))
      {
        case -1:
          mutt_perror("%s", buf_string(folder));
          goto done; // TEST41: neomutt -z -f missing
        case 1:
          mutt_error(_("Mailbox is empty"));
          goto done; // TEST42: neomutt -z -f /dev/null
      }
    }
 
    struct Mailbox *m_cur = mailbox_find(buf_string(folder));
    // Take a copy of the name just in case the hook alters m_cur
    const char *name = m_cur ? mutt_str_dup(m_cur->name) : NULL;
    exec_folder_hook(buf_string(folder), name);
    FREE(&name);
    exec_startup_shutdown_hook(CMD_STARTUP_HOOK);
    mutt_debug(LL_NOTIFY, "NT_GLOBAL_STARTUP\n");
    notify_send(NeoMutt->notify, NT_GLOBAL, NT_GLOBAL_STARTUP, NULL);
 
    notify_send(NeoMutt->notify_resize, NT_RESIZE, 0, NULL);
    window_redraw(NULL);
 
    repeat_error = true;
    struct Mailbox *m = mx_resolve(buf_string(folder));
    const bool c_read_only = cs_subset_bool(NeoMutt->sub, "read_only");
    if (!mx_mbox_open(m, (cli->tui.read_only || c_read_only) ? MUTT_READONLY : MUTT_OPEN_NONE))
    {
      if (m->account)
        account_mailbox_remove(m->account, m);
 
      mailbox_free(&m);
      mutt_error(_("Unable to open mailbox %s"), buf_string(folder));
      repeat_error = false;
    }
    if (m || !explicit_folder)
    {
      struct MuttWindow *dlg = index_pager_init();
      dialog_push(dlg);
 
      mutt_curses_set_cursor(MUTT_CURSOR_INVISIBLE);
      m = dlg_index(dlg, m);
      mutt_curses_set_cursor(MUTT_CURSOR_VISIBLE);
      mailbox_free(&m);
 
      dialog_pop();
      mutt_window_free(&dlg);
      log_queue_empty();
      repeat_error = false;
    }
    imap_logout_all();
    // TEST43: neomutt (no change to mailbox)
    // TEST44: neomutt (change mailbox)
  }
  rc = 0;
 
done:
  neomutt_gui_cleanup(NeoMutt);
  /* Repeat the last message to the user */
  if (repeat_error && ErrorBufMessage)
    puts(ErrorBuf);
 
  if (NeoMutt && NeoMutt->sub)
  {
    notify_observer_remove(NeoMutt->sub->notify, main_hist_observer, NULL);
    notify_observer_remove(NeoMutt->sub->notify, main_log_observer, NULL);
    notify_observer_remove(NeoMutt->notify, main_timeout_observer, NULL);
  }
 
  buf_pool_release(&expanded_infile);
  buf_pool_release(&tempfile);
  if (NeoMutt)
    envlist_free(&NeoMutt->env);
  external_cleanup();
  mutt_ch_cache_cleanup();
  command_line_free(&cli);
 
  source_stack_cleanup();
 
  FREE(&CurrentFolder);
  FREE(&LastFolder);
  FREE(&ShortHostname);
 
  mutt_prex_cleanup();
  config_cache_cleanup();
  MuttLogger = log_disp_queue;
  neomutt_cleanup(NeoMutt);
  neomutt_free(&NeoMutt);
  buf_pool_cleanup();
  log_queue_flush(log_disp_terminal);
  mutt_log_stop();
  return rc;
}

Variable Documentation

StartupComplete

bool StartupComplete = false

When the config has been read.

Definition at line 154 of file main.c.

ModuleMain

const struct Module ModuleMain

extern

Module for the Main library.

Definition at line 63 of file module.c.

                                 {
  MODULE_ID_MAIN,
  "main",
  NULL, // init
  NULL, // config_define_types
  main_config_define_variables,
  NULL, // commands_register
  main_gui_init,
  main_gui_cleanup,
  NULL, // cleanup
};

ModuleAddress

const struct Module ModuleAddress

extern

Module for the Address library.

Definition at line 94 of file module.c.

                                    {
  MODULE_ID_ADDRESS,
  "address",
  address_init,
  address_config_define_types,
  address_config_define_variables,
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  address_cleanup,
};

ModuleAlias

const struct Module ModuleAlias

extern

Module for the Alias library.

Definition at line 128 of file module.c.

                                  {
  MODULE_ID_ALIAS,
  "alias",
  alias_init,
  NULL, // config_define_types
  alias_config_define_variables,
  alias_commands_register,
  NULL, // gui_init
  NULL, // gui_cleanup
  alias_cleanup,
};

ModuleAttach

const struct Module ModuleAttach

extern

Module for the Attach library.

Definition at line 111 of file module.c.

                                   {
  MODULE_ID_ATTACH,
  "attach",
  attach_init,
  NULL, // config_define_types
  attach_config_define_variables,
  attach_commands_register,
  NULL, // gui_init
  NULL, // gui_cleanup
  attach_cleanup,
};

ModuleAutocrypt

const struct Module ModuleAutocrypt

extern

Module for the Autocrypt library.

Definition at line 91 of file module.c.

                                      {
  MODULE_ID_AUTOCRYPT,
  "autocrypt",
  autocrypt_init,
  NULL, // config_define_types
  autocrypt_config_define_variables,
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  autocrypt_cleanup,
};

ModuleBcache

const struct Module ModuleBcache

extern

Module for the Bcache library.

Definition at line 66 of file module.c.

                                   {
  MODULE_ID_BCACHE,
  "bcache",
  bcache_init,
  NULL, // config_define_types
  NULL, // config_define_variables
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  bcache_cleanup,
};

ModuleBrowser

const struct Module ModuleBrowser

extern

Module for the Browser library.

Definition at line 91 of file module.c.

                                    {
  MODULE_ID_BROWSER,
  "browser",
  browser_init,
  NULL, // config_define_types
  browser_config_define_variables,
  NULL, // commands_register
  browser_gui_init,
  NULL, // gui_cleanup
  browser_cleanup,
};

ModuleColor

const struct Module ModuleColor

extern

Module for the Color library.

Definition at line 104 of file module.c.

                                  {
  MODULE_ID_COLOR,
  "color",
  color_init,
  NULL, // config_define_types
  color_config_define_variables,
  color_commands_register,
  color_gui_init,
  color_gui_cleanup,
  color_cleanup,
};

ModuleCommands

const struct Module ModuleCommands

extern

Module for the Commands library.

Definition at line 78 of file module.c.

                                     {
  MODULE_ID_COMMANDS,
  "commands",
  commands_init,
  NULL, // config_define_types
  NULL, // config_define_variables
  commands_commands_register,
  NULL, // gui_init
  NULL, // gui_cleanup
  commands_cleanup,
};

ModuleComplete

const struct Module ModuleComplete

extern

Module for the Complete library.

Definition at line 66 of file module.c.

                                     {
  MODULE_ID_COMPLETE,
  "complete",
  complete_init,
  NULL, // config_define_types
  NULL, // config_define_variables
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  complete_cleanup,
};

ModuleCompmbox

const struct Module ModuleCompmbox

extern

Module for the Compmbox library.

Definition at line 76 of file module.c.

                                     {
  MODULE_ID_COMPMBOX,
  "compmbox",
  compmbox_init,
  NULL, // config_define_types
  NULL, // config_define_variables
  compmbox_commands_register,
  NULL, // gui_init
  NULL, // gui_cleanup
  compmbox_cleanup,
};

ModuleCompose

const struct Module ModuleCompose

extern

Module for the Compose library.

Definition at line 77 of file module.c.

                                    {
  MODULE_ID_COMPOSE,
  "compose",
  compose_init,
  NULL, // config_define_types
  compose_config_define_variables,
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  compose_cleanup,
};

ModuleCompress

const struct Module ModuleCompress

extern

Module for the Compress library.

Definition at line 66 of file module.c.

                                     {
  MODULE_ID_COMPRESS,
  "compress",
  compress_init,
  NULL, // config_define_types
  NULL, // config_define_variables
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  compress_cleanup,
};

ModuleConfig

const struct Module ModuleConfig

extern

Module for the Config library.

Definition at line 103 of file module.c.

                                   {
  MODULE_ID_CONFIG,
  "config",
  config_init,
  config_config_define_types,
  NULL, // config_define_variables
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  config_cleanup,
};

ModuleConn

const struct Module ModuleConn

extern

Module for the Conn library.

Definition at line 128 of file module.c.

                                 {
  MODULE_ID_CONN,
  "conn",
  conn_init,
  NULL, // config_define_types
  conn_config_define_variables,
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  conn_cleanup,
};

ModuleConvert

const struct Module ModuleConvert

extern

Module for the Convert library.

Definition at line 66 of file module.c.

                                    {
  MODULE_ID_CONVERT,
  "convert",
  convert_init,
  NULL, // config_define_types
  NULL, // config_define_variables
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  convert_cleanup,
};

ModuleCore

const struct Module ModuleCore

extern

Module for the Core library.

Definition at line 67 of file module.c.

                                 {
  MODULE_ID_CORE, "core", core_init,
  NULL, // config_define_types
  NULL, // config_define_variables
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  core_cleanup,
};

ModuleEditor

const struct Module ModuleEditor

extern

Module for the Editor library.

Definition at line 66 of file module.c.

                                   {
  MODULE_ID_EDITOR,
  "editor",
  editor_init,
  NULL, // config_define_types
  NULL, // config_define_variables
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  editor_cleanup,
};

ModuleEmail

const struct Module ModuleEmail

extern

Module for the Email library.

Definition at line 127 of file module.c.

                                  {
  MODULE_ID_EMAIL,
  "email",
  email_init,
  NULL, // config_define_types
  email_config_define_variables,
  email_commands_register,
  NULL, // gui_init
  NULL, // gui_cleanup
  email_cleanup,
};

ModuleEnvelope

const struct Module ModuleEnvelope

extern

Module for the Envelope library.

Definition at line 66 of file module.c.

                                     {
  MODULE_ID_ENVELOPE,
  "envelope",
  envelope_init,
  NULL, // config_define_types
  NULL, // config_define_variables
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  envelope_cleanup,
};

ModuleExpando

const struct Module ModuleExpando

extern

Module for the Expando library.

Definition at line 77 of file module.c.

                                    {
  MODULE_ID_EXPANDO,
  "expando",
  expando_init,
  expando_config_define_types,
  NULL, // config_define_variables
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  expando_cleanup,
};

ModuleGui

const struct Module ModuleGui

extern

Module for the Gui library.

Definition at line 145 of file module.c.

                                {
  MODULE_ID_GUI,
  "gui",
  gui_init,
  NULL, // config_define_types
  gui_config_define_variables,
  NULL, // commands_register
  gui_gui_init,
  gui_gui_cleanup,
  gui_cleanup,
};

ModuleHcache

const struct Module ModuleHcache

extern

Module for the Hcache library.

Definition at line 86 of file module.c.

                                   {
  MODULE_ID_HCACHE,
  "hcache",
  hcache_init,
  NULL, // config_define_types
  hcache_config_define_variables,
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  hcache_cleanup,
};

ModuleHelpbar

const struct Module ModuleHelpbar

extern

Module for the Helpbar library.

Definition at line 77 of file module.c.

                                    {
  MODULE_ID_HELPBAR,
  "helpbar",
  helpbar_init,
  NULL, // config_define_types
  helpbar_config_define_variables,
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  helpbar_cleanup,
};

ModuleHistory

const struct Module ModuleHistory

extern

Module for the History library.

Definition at line 98 of file module.c.

                                    {
  MODULE_ID_HISTORY,
  "history",
  history_init,
  NULL, // config_define_types
  history_config_define_variables,
  NULL, // commands_register
  history_gui_init,
  history_gui_cleanup,
  history_cleanup,
};

ModuleHooks

const struct Module ModuleHooks

extern

Module for the Hooks library.

Definition at line 92 of file module.c.

                                  {
  MODULE_ID_HOOKS,
  "hooks",
  hooks_init,
  NULL, // config_define_types
  hooks_config_define_variables,
  hooks_commands_register,
  NULL, // gui_init
  NULL, // gui_cleanup
  hooks_cleanup,
};

ModuleImap

const struct Module ModuleImap

extern

Module for the Imap library.

Definition at line 96 of file module.c.

                                 {
  MODULE_ID_IMAP,
  "imap",
  imap_init,
  NULL, // config_define_types
  imap_config_define_variables,
  imap_commands_register,
  NULL, // gui_init
  NULL, // gui_cleanup
  imap_cleanup,
};

ModuleIndex

const struct Module ModuleIndex

extern

Module for the Index library.

Definition at line 91 of file module.c.

                                  {
  MODULE_ID_INDEX,
  "index",
  index_init,
  NULL, // config_define_types
  index_config_define_variables,
  index_commands_register,
  NULL, // gui_init
  NULL, // gui_cleanup
  index_cleanup,
};

ModuleKey

const struct Module ModuleKey

extern

Module for the Key library.

Definition at line 99 of file module.c.

                                {
  MODULE_ID_KEY,
  "key",
  key_init,
  NULL, // config_define_types
  NULL, // config_define_variables
  key_commands_register,
  key_gui_init,
  key_gui_cleanup,
  key_cleanup,
};

ModuleLua

const struct Module ModuleLua

extern

Module for the Lua library.

Definition at line 84 of file module.c.

                                {
  MODULE_ID_LUA,
  "lua",
  lua_init,
  NULL, // config_define_types
  NULL, // config_define_variables
  lua_commands_register,
  NULL, // gui_init
  NULL, // gui_cleanup
  lua_cleanup,
};

ModuleMaildir

const struct Module ModuleMaildir

extern

Module for the Maildir library.

Definition at line 84 of file module.c.

                                    {
  MODULE_ID_MAILDIR,
  "maildir",
  maildir_init,
  NULL, // config_define_types
  maildir_config_define_variables,
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  maildir_cleanup,
};

ModuleMbox

const struct Module ModuleMbox

extern

Module for the Mbox library.

Definition at line 77 of file module.c.

                                 {
  MODULE_ID_MBOX,
  "mbox",
  mbox_init,
  NULL, // config_define_types
  mbox_config_define_variables,
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  mbox_cleanup,
};

ModuleMenu

const struct Module ModuleMenu

extern

Module for the Menu library.

Definition at line 101 of file module.c.

                                 {
  MODULE_ID_MENU,
  "menu",
  menu_init,
  NULL, // config_define_types
  menu_config_define_variables,
  NULL, // commands_register
  menu_gui_init,
  menu_gui_cleanup,
  menu_cleanup,
};

ModuleMh

const struct Module ModuleMh

extern

Module for the Mh library.

Definition at line 77 of file module.c.

                               {
  MODULE_ID_MH,
  "mh",
  mh_init,
  NULL, // config_define_types
  mh_config_define_variables,
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  mh_cleanup,
};

ModuleMutt

const struct Module ModuleMutt

extern

Module for the Mutt library.

Definition at line 68 of file module.c.

                                 {
  MODULE_ID_MUTT, "mutt", mutt_init,
  NULL, // config_define_types
  NULL, // config_define_variables
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  mutt_cleanup,
};

ModuleNcrypt

const struct Module ModuleNcrypt

extern

Module for the Ncrypt library.

Definition at line 105 of file module.c.

                                   {
  MODULE_ID_NCRYPT,
  "ncrypt",
  ncrypt_init,
  NULL, // config_define_types
  ncrypt_config_define_variables,
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  ncrypt_cleanup,
};

ModuleNntp

const struct Module ModuleNntp

extern

Module for the Nntp library.

Definition at line 77 of file module.c.

                                 {
  MODULE_ID_NNTP,
  "nntp",
  nntp_init,
  NULL, // config_define_types
  nntp_config_define_variables,
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  nntp_cleanup,
};

ModuleNotmuch

const struct Module ModuleNotmuch

extern

Module for the Notmuch library.

Definition at line 118 of file module.c.

                                    {
  MODULE_ID_NOTMUCH,
  "notmuch",
  notmuch_init,
  NULL, // config_define_types
  notmuch_config_define_variables,
  notmuch_commands_register,
  notmuch_gui_init,
  notmuch_gui_cleanup,
  notmuch_cleanup,
};

ModulePager

const struct Module ModulePager

extern

Module for the Pager library.

Definition at line 80 of file module.c.

                                  {
  MODULE_ID_PAGER,
  "pager",
  pager_init,
  NULL, // config_define_types
  pager_config_define_variables,
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  pager_cleanup,
};

ModuleParse

const struct Module ModuleParse

extern

Module for the Parse library.

Definition at line 66 of file module.c.

                                  {
  MODULE_ID_PARSE,
  "parse",
  parse_init,
  NULL, // config_define_types
  NULL, // config_define_variables
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  parse_cleanup,
};

ModulePattern

const struct Module ModulePattern

extern

Module for the Pattern library.

Definition at line 93 of file module.c.

                                    {
  MODULE_ID_PATTERN,
  "pattern",
  pattern_init,
  NULL, // config_define_types
  pattern_config_define_variables,
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  pattern_cleanup,
};

ModulePop

const struct Module ModulePop

extern

Module for the Pop library.

Definition at line 77 of file module.c.

                                {
  MODULE_ID_POP,
  "pop",
  pop_init,
  NULL, // config_define_types
  pop_config_define_variables,
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  pop_cleanup,
};

ModulePostpone

const struct Module ModulePostpone

extern

Module for the Postpone library.

Definition at line 66 of file module.c.

                                     {
  MODULE_ID_POSTPONE,
  "postpone",
  postpone_init,
  NULL, // config_define_types
  NULL, // config_define_variables
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  postpone_cleanup,
};

ModuleProgress

const struct Module ModuleProgress

extern

Module for the Progress library.

Definition at line 77 of file module.c.

                                     {
  MODULE_ID_PROGRESS,
  "progress",
  progress_init,
  NULL, // config_define_types
  progress_config_define_variables,
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  progress_cleanup,
};

ModuleQuestion

const struct Module ModuleQuestion

extern

Module for the Question library.

Definition at line 66 of file module.c.

                                     {
  MODULE_ID_QUESTION,
  "question",
  question_init,
  NULL, // config_define_types
  NULL, // config_define_variables
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  question_cleanup,
};

ModuleSend

const struct Module ModuleSend

extern

Module for the Send library.

Definition at line 91 of file module.c.

                                 {
  MODULE_ID_SEND,
  "send",
  send_init,
  NULL, // config_define_types
  send_config_define_variables,
  send_commands_register,
  NULL, // gui_init
  NULL, // gui_cleanup
  send_cleanup,
};

ModuleSidebar

const struct Module ModuleSidebar

extern

Module for the Sidebar library.

Definition at line 111 of file module.c.

                                    {
  MODULE_ID_SIDEBAR,
  "sidebar",
  sidebar_init,
  NULL, // config_define_types
  sidebar_config_define_variables,
  sidebar_commands_register,
  sidebar_gui_init,
  sidebar_gui_cleanup,
  sidebar_cleanup,
};

ModuleStore

const struct Module ModuleStore

extern

Module for the Store library.

Definition at line 66 of file module.c.

                                  {
  MODULE_ID_STORE,
  "store",
  store_init,
  NULL, // config_define_types
  NULL, // config_define_variables
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  store_cleanup,
};

Modules

const struct Module* Modules[]

static

All the library Modules.

Definition at line 177 of file main.c.

                                        {
  // clang-format off
  &ModuleMain,     &ModuleGui,      // These two have priority
  &ModuleAddress,  &ModuleAlias,    &ModuleAttach,   &ModuleBcache,   &ModuleBrowser,
  &ModuleColor,    &ModuleCommands, &ModuleComplete, &ModuleCompmbox, &ModuleCompose,
  &ModuleConfig,   &ModuleConn,     &ModuleConvert,  &ModuleCore,     &ModuleEditor,
  &ModuleEmail,    &ModuleEnvelope, &ModuleExpando,  &ModuleHelpbar,  &ModuleHistory,
  &ModuleHooks,    &ModuleImap,     &ModuleIndex,    &ModuleKey,      &ModuleMaildir,
  &ModuleMbox,     &ModuleMenu,     &ModuleMh,       &ModuleMutt,     &ModuleNcrypt,
  &ModuleNntp,     &ModulePager,    &ModuleParse,    &ModulePattern,  &ModulePop,
  &ModulePostpone, &ModuleProgress, &ModuleQuestion, &ModuleSend,     &ModuleSidebar,
// clang-format on
#ifdef USE_AUTOCRYPT
  &ModuleAutocrypt,
#endif
#ifdef USE_HCACHE_COMPRESSION
  &ModuleCompress,
#endif
#ifdef USE_HCACHE
  &ModuleHcache,
#endif
#ifdef USE_LUA
  &ModuleLua,
#endif
#ifdef USE_NOTMUCH
  &ModuleNotmuch,
#endif
#ifdef USE_HCACHE
  &ModuleStore,
#endif
  NULL,
};