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 "lua/lib.h"
#include "menu/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 "external.h"
#include "globals.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 (void)
	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 void	log_gui (void)
	Log info about the GUI.
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 97 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 225 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 264 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 311 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_NO_FLAGS);
    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 344 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 */
  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 430 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);
 
  /* "$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 680 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 ( void )

static

Initialise the Keybindings.

Definition at line 710 of file main.c.

{
  km_init();
 
  struct SubMenu *sm_generic = generic_init_keys();
 
  alias_init_keys(sm_generic);
  attach_init_keys(sm_generic);
#ifdef USE_AUTOCRYPT
  autocrypt_init_keys(sm_generic);
#endif
  browser_init_keys(sm_generic);
  compose_init_keys(sm_generic);
  editor_init_keys(sm_generic);
  sidebar_init_keys(sm_generic);
  index_init_keys(sm_generic);
  pager_init_keys(sm_generic);
  pgp_init_keys(sm_generic);
  postponed_init_keys(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 738 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;
  }
 
  colors_init();
  keypad(stdscr, true);
  cbreak();
  noecho();
  nonl();
  typeahead(-1); /* simulate smooth scrolling */
  meta(stdscr, true);
  ext_keys_init();
  /* 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 772 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 813 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);
    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:

log_gui()

static void log_gui ( void )

static

Log info about the GUI.

Definition at line 839 of file main.c.

{
  const char *term = mutt_str_getenv("TERM");
  const char *color_term = mutt_str_getenv("COLORTERM");
  bool true_color = false;
#ifdef NEOMUTT_DIRECT_COLORS
  true_color = true;
#endif
 
  mutt_debug(LL_DEBUG1, "GUI:\n");
  mutt_debug(LL_DEBUG1, "    Curses: %s\n", curses_version());
  mutt_debug(LL_DEBUG1, "    COLORS=%d\n", COLORS);
  mutt_debug(LL_DEBUG1, "    COLOR_PAIRS=%d\n", COLOR_PAIRS);
  mutt_debug(LL_DEBUG1, "    TERM=%s\n", NONULL(term));
  mutt_debug(LL_DEBUG1, "    COLORTERM=%s\n", NONULL(color_term));
  mutt_debug(LL_DEBUG1, "    True color support: %s\n", true_color ? "YES" : "NO");
  mutt_debug(LL_DEBUG1, "    Screen: %dx%d\n", RootWindow->state.cols,
             RootWindow->state.rows);
}

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 896 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 927 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 956 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 985 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_NO_FLAGS;
    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 1049 of file main.c.

{
  struct Email *e = NULL;
  SendFlags sendflags = SEND_NO_FLAGS;
  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();
 
  MuttLogger = log_disp_terminal;
 
  /* 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 main_exit; // TEST01: neomutt (as root, chgrp mail neomutt; chmod +s neomutt)
  }
 
  OptGui = true;
 
  NeoMutt = neomutt_new();
  if (!neomutt_init(NeoMutt, envp, Modules))
    goto main_curses;
 
  cli_parse(argc, argv, cli);
 
  if (!show_help(&cli->help))
    goto main_ok;
 
  init_keys();
 
#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 main_exit;
 
  if (!init_logging(&cli->shared, cs))
    goto main_exit;
 
  mutt_log_prep();
  MuttLogger = log_disp_queue;
  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 main_curses;
 
  /* 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 main_curses; // TEST08: can't test -- fake term?
  }
 
  /* Always create the mutt_windows because batch mode has some shared code
   * paths that end up referencing them. */
  rootwin_new();
 
  if (OptGui)
  {
    /* check whether terminal status is supported (must follow curses init) */
    TsSupported = mutt_ts_capability();
    mutt_resize_screen();
    log_gui();
  }
 
  menu_init();
  sb_init();
 
  /* 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 main_curses;
 
  mutt_hist_init();
  mutt_hist_read_file();
 
#ifdef USE_NOTMUCH
  const bool c_virtual_spool_file = cs_subset_bool(NeoMutt->sub, "virtual_spool_file");
  if (c_virtual_spool_file)
  {
    /* Find the first virtual folder and open it */
    struct MailboxArray ma = neomutt_mailboxes_get(NeoMutt, MUTT_NOTMUCH);
    struct Mailbox **mp = ARRAY_FIRST(&ma);
    if (mp)
      cs_str_string_set(cs, "spool_file", mailbox_path(*mp), NULL);
    ARRAY_FREE(&ma); // Clean up the ARRAY, but not the Mailboxes
  }
#endif
 
  km_set_abort_key();
 
  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 main_curses;
  }
 
  if (!dump_info(&cli->info, cs))
    goto main_ok;
 
  if (OptGui)
  {
    mutt_curses_set_color_by_id(MT_COLOR_NORMAL);
    clear();
    MuttLogger = log_disp_curses;
    log_queue_flush(log_disp_curses);
    log_queue_set_max_size(100);
  }
 
#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)
    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 main_curses;
  }
  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();
 
    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 main_curses; // 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 main_curses; // 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 main_curses; // 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 main_curses; // 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(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 main_curses; // 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 main_curses; // 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 main_curses; // 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 main_curses;
        }
 
        /* 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 main_curses; // 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 main_curses; // 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 main_curses; // 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 main_curses; // 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();
 
    if (rv != 0)
      goto main_curses; // 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 main_curses;
  }
  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"));
        repeat_error = true;
        goto main_curses; // 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)
      {
        const char *const c_news_server = cs_subset_string(NeoMutt->sub, "news_server");
        OptNews = true;
        CurrentNewsSrv = nntp_select_server(NULL, c_news_server, false);
        if (!CurrentNewsSrv)
          goto main_curses; // TEST38: neomutt -G (unset news_server)
      }
      else if (ARRAY_EMPTY(&NeoMutt->accounts))
      {
        mutt_error(_("No incoming mailboxes defined"));
        goto main_curses; // 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))
      {
        goto main_ok; // 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)
    {
      OptNews = false;
      buf_alloc(folder, PATH_MAX);
      nntp_expand_path(folder->data, folder->dsize, &CurrentNewsSrv->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 main_curses; // TEST41: neomutt -z -f missing
        case 1:
          mutt_error(_("Mailbox is empty"));
          goto main_curses; // 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_NO_FLAGS))
    {
      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();
#ifdef USE_SASL_CYRUS
    mutt_sasl_cleanup();
#endif
#ifdef USE_SASL_GNU
    mutt_gsasl_cleanup();
#endif
#ifdef USE_AUTOCRYPT
    mutt_autocrypt_cleanup();
#endif
    // TEST43: neomutt (no change to mailbox)
    // TEST44: neomutt (change mailbox)
  }
 
main_ok:
  rc = 0;
main_curses:
  mutt_endwin();
  /* Repeat the last message to the user */
  if (repeat_error && ErrorBufMessage)
    puts(ErrorBuf);
main_exit:
  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);
  crypto_module_cleanup();
  rootwin_cleanup();
  if (NeoMutt)
    envlist_free(&NeoMutt->env);
  mutt_browser_cleanup();
  external_cleanup();
  menu_cleanup();
  crypt_cleanup();
  mutt_ch_cache_cleanup();
  command_line_free(&cli);
 
  source_stack_cleanup();
 
  sb_cleanup();
 
  colors_cleanup();
 
  FREE(&CurrentFolder);
  FREE(&LastFolder);
  FREE(&ShortHostname);
 
  mutt_delete_hooks(CMD_NONE);
 
  mutt_hist_cleanup();
 
  lua_cleanup();
  km_cleanup();
  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 163 of file main.c.

ModuleMain

const struct Module ModuleMain

extern

Module for the Main library.

Definition at line 48 of file module.c.

                                 {
  MODULE_ID_MAIN,
  "main",
  NULL, // init
  NULL, // config_define_types
  main_config_define_variables,
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  NULL, // cleanup
};

ModuleAddress

const struct Module ModuleAddress

extern

Module for the Address library.

Definition at line 65 of file module.c.

                                    {
  MODULE_ID_ADDRESS,
  "address",
  NULL, // init
  address_config_define_types,
  address_config_define_variables,
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  NULL, // cleanup
};

ModuleAlias

const struct Module ModuleAlias

extern

Module for the Alias library.

Definition at line 108 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 108 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 54 of file module.c.

                                      {
  MODULE_ID_AUTOCRYPT,
  "autocrypt",
  NULL, // init
  NULL, // config_define_types
  autocrypt_config_define_variables,
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  NULL, // cleanup
};

ModuleBcache

const struct Module ModuleBcache

extern

Module for the Bcache library.

Definition at line 36 of file module.c.

                                   {
  MODULE_ID_BCACHE,
  "bcache",
  NULL, // init
  NULL, // config_define_types
  NULL, // config_define_variables
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  NULL, // cleanup
};

ModuleBrowser

const struct Module ModuleBrowser

extern

Module for the Browser library.

Definition at line 48 of file module.c.

                                    {
  MODULE_ID_BROWSER,
  "browser",
  NULL, // init
  NULL, // config_define_types
  browser_config_define_variables,
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  NULL, // cleanup
};

ModuleColor

const struct Module ModuleColor

extern

Module for the Color library.

Definition at line 36 of file module.c.

                                  {
  MODULE_ID_COLOR,
  "color",
  NULL, // init
  NULL, // config_define_types
  NULL, // config_define_variables
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  NULL, // cleanup
};

ModuleCommands

const struct Module ModuleCommands

extern

Module for the Commands library.

Definition at line 47 of file module.c.

                                     {
  MODULE_ID_COMMANDS,
  "commands",
  NULL, // init
  NULL, // config_define_types
  NULL, // config_define_variables
  commands_commands_register,
  NULL, // gui_init
  NULL, // gui_cleanup
  NULL, // cleanup
};

ModuleComplete

const struct Module ModuleComplete

extern

Module for the Complete library.

Definition at line 36 of file module.c.

                                     {
  MODULE_ID_COMPLETE,
  "complete",
  NULL, // init
  NULL, // config_define_types
  NULL, // config_define_variables
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  NULL, // cleanup
};

ModuleCompmbox

const struct Module ModuleCompmbox

extern

Module for the Compmbox library.

Definition at line 47 of file module.c.

                                     {
  MODULE_ID_COMPMBOX,
  "compmbox",
  NULL, // init
  NULL, // config_define_types
  NULL, // config_define_variables
  compmbox_commands_register,
  NULL, // gui_init
  NULL, // gui_cleanup
  NULL, // cleanup
};

ModuleCompose

const struct Module ModuleCompose

extern

Module for the Compose library.

Definition at line 48 of file module.c.

                                    {
  MODULE_ID_COMPOSE,
  "compose",
  NULL, // init
  NULL, // config_define_types
  compose_config_define_variables,
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  NULL, // cleanup
};

ModuleCompress

const struct Module ModuleCompress

extern

Module for the Compress library.

Definition at line 36 of file module.c.

                                     {
  MODULE_ID_COMPRESS,
  "compress",
  NULL, // init
  NULL, // config_define_types
  NULL, // config_define_variables
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  NULL, // cleanup
};

ModuleConfig

const struct Module ModuleConfig

extern

Module for the Config library.

Definition at line 74 of file module.c.

                                   {
  MODULE_ID_CONFIG,
  "config",
  NULL, // init
  config_config_define_types,
  NULL, // config_define_variables
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  NULL, // cleanup
};

ModuleConn

const struct Module ModuleConn

extern

Module for the Conn library.

Definition at line 77 of file module.c.

                                 {
  MODULE_ID_CONN,
  "conn",
  NULL, // init
  NULL, // config_define_types
  conn_config_define_variables,
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  NULL, // cleanup
};

ModuleConvert

const struct Module ModuleConvert

extern

Module for the Convert library.

Definition at line 36 of file module.c.

                                    {
  MODULE_ID_CONVERT,
  "convert",
  NULL, // init
  NULL, // config_define_types
  NULL, // config_define_variables
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  NULL, // cleanup
};

ModuleCore

const struct Module ModuleCore

extern

Module for the Core library.

Definition at line 36 of file module.c.

                                 {
  MODULE_ID_CORE, "core",
  NULL, // init
  NULL, // config_define_types
  NULL, // config_define_variables
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  NULL, // cleanup
};

ModuleEditor

const struct Module ModuleEditor

extern

Module for the Editor library.

Definition at line 36 of file module.c.

                                   {
  MODULE_ID_EDITOR,
  "editor",
  NULL, // init
  NULL, // config_define_types
  NULL, // config_define_variables
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  NULL, // cleanup
};

ModuleEmail

const struct Module ModuleEmail

extern

Module for the Email library.

Definition at line 132 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 36 of file module.c.

                                     {
  MODULE_ID_ENVELOPE,
  "envelope",
  NULL, // init
  NULL, // config_define_types
  NULL, // config_define_variables
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  NULL, // cleanup
};

ModuleExpando

const struct Module ModuleExpando

extern

Module for the Expando library.

Definition at line 48 of file module.c.

                                    {
  MODULE_ID_EXPANDO,
  "expando",
  NULL, // init
  expando_config_define_types,
  NULL, // config_define_variables
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  NULL, // cleanup
};

ModuleGui

const struct Module ModuleGui

extern

Module for the Gui library.

Definition at line 48 of file module.c.

                                {
  MODULE_ID_GUI,
  "gui",
  NULL, // init
  NULL, // config_define_types
  gui_config_define_variables,
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  NULL, // cleanup
};

ModuleHcache

const struct Module ModuleHcache

extern

Module for the Hcache library.

Definition at line 69 of file module.c.

                                   {
  MODULE_ID_HCACHE,
  "hcache",
  NULL, // init
  NULL, // config_define_types
  hcache_config_define_variables,
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  NULL, // cleanup
};

ModuleHelpbar

const struct Module ModuleHelpbar

extern

Module for the Helpbar library.

Definition at line 48 of file module.c.

                                    {
  MODULE_ID_HELPBAR,
  "helpbar",
  NULL, // init
  NULL, // config_define_types
  helpbar_config_define_variables,
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  NULL, // cleanup
};

ModuleHistory

const struct Module ModuleHistory

extern

Module for the History library.

Definition at line 48 of file module.c.

                                    {
  MODULE_ID_HISTORY,
  "history",
  NULL, // init
  NULL, // config_define_types
  history_config_define_variables,
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  NULL, // cleanup
};

ModuleHooks

const struct Module ModuleHooks

extern

Module for the Hooks library.

Definition at line 57 of file module.c.

                                  {
  MODULE_ID_HOOKS,
  "hooks",
  NULL, // init
  NULL, // config_define_types
  hooks_config_define_variables,
  hooks_commands_register,
  NULL, // gui_init
  NULL, // gui_cleanup
  NULL, // cleanup
};

ModuleImap

const struct Module ModuleImap

extern

Module for the Imap library.

Definition at line 65 of file module.c.

                                 {
  MODULE_ID_IMAP,
  "imap",
  NULL, // init
  NULL, // config_define_types
  imap_config_define_variables,
  imap_commands_register,
  NULL, // gui_init
  NULL, // gui_cleanup
  NULL, // cleanup
};

ModuleIndex

const struct Module ModuleIndex

extern

Module for the Index library.

Definition at line 87 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 47 of file module.c.

                                {
  MODULE_ID_KEY,
  "key",
  NULL, // init
  NULL, // config_define_types
  NULL, // config_define_variables
  key_commands_register,
  NULL, // gui_init
  NULL, // gui_cleanup
  NULL, // cleanup
};

ModuleLua

const struct Module ModuleLua

extern

Module for the Lua library.

Definition at line 47 of file module.c.

                                {
  MODULE_ID_LUA,
  "lua",
  NULL, // init
  NULL, // config_define_types
  NULL, // config_define_variables
  lua_commands_register,
  NULL, // gui_init
  NULL, // gui_cleanup
  NULL, // cleanup
};

ModuleMaildir

const struct Module ModuleMaildir

extern

Module for the Maildir library.

Definition at line 55 of file module.c.

                                    {
  MODULE_ID_MAILDIR,
  "maildir",
  NULL, // init
  NULL, // config_define_types
  maildir_config_define_variables,
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  NULL, // cleanup
};

ModuleMbox

const struct Module ModuleMbox

extern

Module for the Mbox library.

Definition at line 48 of file module.c.

                                 {
  MODULE_ID_MBOX,
  "mbox",
  NULL, // init
  NULL, // config_define_types
  mbox_config_define_variables,
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  NULL, // cleanup
};

ModuleMenu

const struct Module ModuleMenu

extern

Module for the Menu library.

Definition at line 48 of file module.c.

                                 {
  MODULE_ID_MENU,
  "menu",
  NULL, // init
  NULL, // config_define_types
  menu_config_define_variables,
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  NULL, // cleanup
};

ModuleMh

const struct Module ModuleMh

extern

Module for the Mh library.

Definition at line 48 of file module.c.

                               {
  MODULE_ID_MH,
  "mh",
  NULL, // init
  NULL, // config_define_types
  mh_config_define_variables,
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  NULL, // cleanup
};

ModuleMutt

const struct Module ModuleMutt

extern

Module for the Mutt library.

Definition at line 36 of file module.c.

                                 {
  MODULE_ID_MUTT, "mutt",
  NULL, // init
  NULL, // config_define_types
  NULL, // config_define_variables
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  NULL, // cleanup
};

ModuleNcrypt

const struct Module ModuleNcrypt

extern

Module for the Ncrypt library.

Definition at line 67 of file module.c.

                                   {
  MODULE_ID_NCRYPT,
  "ncrypt",
  NULL, // init
  NULL, // config_define_types
  ncrypt_config_define_variables,
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  NULL, // cleanup
};

ModuleNntp

const struct Module ModuleNntp

extern

Module for the Nntp library.

Definition at line 48 of file module.c.

                                 {
  MODULE_ID_NNTP,
  "nntp",
  NULL, // init
  NULL, // config_define_types
  nntp_config_define_variables,
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  NULL, // cleanup
};

ModuleNotmuch

const struct Module ModuleNotmuch

extern

Module for the Notmuch library.

Definition at line 64 of file module.c.

                                    {
  MODULE_ID_NOTMUCH,
  "notmuch",
  NULL, // init
  NULL, // config_define_types
  notmuch_config_define_variables,
  notmuch_commands_register,
  NULL, // gui_init
  NULL, // gui_cleanup
  NULL, // cleanup
};

ModulePager

const struct Module ModulePager

extern

Module for the Pager library.

Definition at line 48 of file module.c.

                                  {
  MODULE_ID_PAGER,
  "pager",
  NULL, // init
  NULL, // config_define_types
  pager_config_define_variables,
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  NULL, // cleanup
};

ModuleParse

const struct Module ModuleParse

extern

Module for the Parse library.

Definition at line 36 of file module.c.

                                  {
  MODULE_ID_PARSE,
  "parse",
  NULL, // init
  NULL, // config_define_types
  NULL, // config_define_variables
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  NULL, // cleanup
};

ModulePattern

const struct Module ModulePattern

extern

Module for the Pattern library.

Definition at line 48 of file module.c.

                                    {
  MODULE_ID_PATTERN,
  "pattern",
  NULL, // init
  NULL, // config_define_types
  pattern_config_define_variables,
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  NULL, // cleanup
};

ModulePop

const struct Module ModulePop

extern

Module for the Pop library.

Definition at line 48 of file module.c.

                                {
  MODULE_ID_POP,
  "pop",
  NULL, // init
  NULL, // config_define_types
  pop_config_define_variables,
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  NULL, // cleanup
};

ModulePostpone

const struct Module ModulePostpone

extern

Module for the Postpone library.

Definition at line 36 of file module.c.

                                     {
  MODULE_ID_POSTPONE,
  "postpone",
  NULL, // init
  NULL, // config_define_types
  NULL, // config_define_variables
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  NULL, // cleanup
};

ModuleProgress

const struct Module ModuleProgress

extern

Module for the Progress library.

Definition at line 48 of file module.c.

                                     {
  MODULE_ID_PROGRESS,
  "progress",
  NULL, // init
  NULL, // config_define_types
  progress_config_define_variables,
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  NULL, // cleanup
};

ModuleQuestion

const struct Module ModuleQuestion

extern

Module for the Question library.

Definition at line 36 of file module.c.

                                     {
  MODULE_ID_QUESTION,
  "question",
  NULL, // init
  NULL, // config_define_types
  NULL, // config_define_variables
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  NULL, // cleanup
};

ModuleSend

const struct Module ModuleSend

extern

Module for the Send library.

Definition at line 87 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 58 of file module.c.

                                    {
  MODULE_ID_SIDEBAR,
  "sidebar",
  NULL, // init
  NULL, // config_define_types
  sidebar_config_define_variables,
  sidebar_commands_register,
  NULL, // gui_init
  NULL, // gui_cleanup
  NULL, // cleanup
};

ModuleStore

const struct Module ModuleStore

extern

Module for the Store library.

Definition at line 36 of file module.c.

                                  {
  MODULE_ID_STORE,
  "store",
  NULL, // init
  NULL, // config_define_types
  NULL, // config_define_variables
  NULL, // commands_register
  NULL, // gui_init
  NULL, // gui_cleanup
  NULL, // cleanup
};

Modules

const struct Module* Modules[]

static

All the library Modules.

Definition at line 186 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,
};