init.h File Reference

Config/command parsing. More...

#include <stdbool.h>

Include dependency graph for init.h:

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

Go to the source code of this file.

Functions
void	init_config (struct ConfigSet *cs)
	Initialise the config system.
int	mutt_init (struct ConfigSet *cs, bool skip_sys_rc, struct ListHead *commands)
	Initialise NeoMutt.
void	mutt_opts_cleanup (void)
	Clean up before quitting.
int	mutt_query_variables (struct ListHead *queries, bool show_docs)
	Implement the -Q command line flag.

Detailed Description

Config/command parsing.

Authors

• Michael R. Elkins
• g10 Code GmbH

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 init.h.

Function Documentation

init_config()

void init_config

(

struct ConfigSet *

cs

)

Initialise the config system.

Parameters

cs	Config items

Definition at line 728 of file mutt_config.c.

{
  init_types(cs);
  init_variables(cs);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_init()

int mutt_init	(	struct ConfigSet *	cs,
		bool	skip_sys_rc,
		struct ListHead *	commands
	)

Initialise NeoMutt.

Parameters

cs	Config Set
skip_sys_rc	If true, don't read the system config file
commands	List of config commands to execute

Return values

0	Success
1	Error

Definition at line 321 of file init.c.

{
  int need_pause = 0;
  int rc = 1;
  struct Buffer err = buf_make(256);
  struct Buffer buf = buf_make(256);
 
  mutt_grouplist_init();
  alias_init();
  commands_init();
  hooks_init();
#ifdef USE_COMP_MBOX
  mutt_comp_init();
#endif
#ifdef USE_IMAP
  imap_init();
#endif
#ifdef USE_LUA
  mutt_lua_init();
#endif
  driver_tags_init();
 
  menu_init();
#ifdef USE_SIDEBAR
  sb_init();
#endif
#ifdef USE_NOTMUCH
  nm_init();
#endif
 
#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")))
    {
      cs_str_initial_set(cs, "color_directcolor", "yes", NULL);
      cs_str_reset(cs, "color_directcolor", NULL);
    }
  }
#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(HomeDir), MAILPATH);
#else
    buf_concat_path(&buf, MAILPATH, NONULL(Username));
#endif
    p = buf_string(&buf);
  }
  cs_str_initial_set(cs, "spool_file", p, NULL);
  cs_str_reset(cs, "spool_file", NULL);
 
  p = mutt_str_getenv("REPLYTO");
  if (p)
  {
    struct Buffer token;
 
    buf_printf(&buf, "Reply-To: %s", p);
    buf_init(&token);
    parse_my_hdr(&token, &buf, 0, &err); /* adds to UserHeader */
    FREE(&token.data);
  }
 
  p = mutt_str_getenv("EMAIL");
  if (p)
  {
    cs_str_initial_set(cs, "from", p, NULL);
    cs_str_reset(cs, "from", NULL);
  }
 
  /* "$mailcap_path" precedence: config file, environment, code */
  const char *env_mc = mutt_str_getenv("MAILCAPS");
  if (env_mc)
  {
    cs_str_initial_set(cs, "mailcap_path", env_mc, NULL);
    cs_str_reset(cs, "mailcap_path", NULL);
  }
 
  /* "$tmp_dir" precedence: config file, environment, code */
  const char *env_tmp = mutt_str_getenv("TMPDIR");
  if (env_tmp)
  {
    cs_str_initial_set(cs, "tmp_dir", env_tmp, NULL);
    cs_str_reset(cs, "tmp_dir", NULL);
  }
 
  /* "$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";
  cs_str_initial_set(cs, "editor", env_ed, NULL);
 
  const char *const c_editor = cs_subset_string(NeoMutt->sub, "editor");
  if (!c_editor)
    cs_str_reset(cs, "editor", NULL);
 
  const char *charset = mutt_ch_get_langinfo_charset();
  cs_str_initial_set(cs, "charset", charset, NULL);
  cs_str_reset(cs, "charset", NULL);
  mutt_ch_set_charset(charset);
  FREE(&charset);
 
#ifdef HAVE_GETSID
  /* Unset suspend by default if we're the session leader */
  if (getsid(0) == getpid())
  {
    cs_str_initial_set(cs, "suspend", "no", NULL);
    cs_str_reset(cs, "suspend", NULL);
  }
#endif
 
  /* RFC2368, "4. Unsafe headers"
   * The creator of a mailto URL can't expect the resolver of a URL to
   * understand more than the "subject" and "body" headers. Clients that
   * resolve mailto URLs into mail messages should be able to correctly
   * create RFC822-compliant mail messages using the "subject" and "body"
   * headers.  */
  add_to_stailq(&MailToAllow, "body");
  add_to_stailq(&MailToAllow, "subject");
  /* Cc, In-Reply-To, and References help with not breaking threading on
   * mailing lists, see https://github.com/neomutt/neomutt/issues/115 */
  add_to_stailq(&MailToAllow, "cc");
  add_to_stailq(&MailToAllow, "in-reply-to");
  add_to_stailq(&MailToAllow, "references");
 
  if (STAILQ_EMPTY(&Muttrc))
  {
    const char *xdg_cfg_home = mutt_str_getenv("XDG_CONFIG_HOME");
 
    if (!xdg_cfg_home && HomeDir)
    {
      buf_printf(&buf, "%s/.config", HomeDir);
      xdg_cfg_home = buf_string(&buf);
    }
 
    char *config = find_cfg(HomeDir, xdg_cfg_home);
    if (config)
    {
      mutt_list_insert_tail(&Muttrc, config);
    }
  }
  else
  {
    struct ListNode *np = NULL;
    STAILQ_FOREACH(np, &Muttrc, entries)
    {
      buf_strcpy(&buf, np->data);
      FREE(&np->data);
      buf_expand_path(&buf);
      np->data = buf_strdup(&buf);
      if (access(np->data, F_OK))
      {
        mutt_perror("%s", np->data);
        goto done; // TEST10: neomutt -F missing
      }
    }
  }
 
  if (!STAILQ_EMPTY(&Muttrc))
  {
    cs_str_string_set(cs, "alias_file", STAILQ_FIRST(&Muttrc)->data, NULL);
  }
 
  /* 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), &err) != 0)
      {
        mutt_error("%s", err.data);
        need_pause = 1; // TEST11: neomutt (error in /etc/neomuttrc)
      }
    }
  }
 
  /* Read the user's initialization file.  */
  struct ListNode *np = NULL;
  STAILQ_FOREACH(np, &Muttrc, entries)
  {
    if (np->data)
    {
      if (source_rc(np->data, &err) != 0)
      {
        mutt_error("%s", err.data);
        need_pause = 1; // TEST12: neomutt (error in ~/.neomuttrc)
      }
    }
  }
 
  if (execute_commands(commands) != 0)
    need_pause = 1; // TEST13: neomutt -e broken
 
  if (!get_hostname(cs))
    goto done;
 
  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);
    }
  }
  cs_str_initial_set(cs, "real_name", c_real_name, NULL);
  cs_str_reset(cs, "real_name", NULL);
 
  if (need_pause && !OptNoCurses)
  {
    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;
  }
 
  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 MailboxList ml = STAILQ_HEAD_INITIALIZER(ml);
    neomutt_mailboxlist_get_all(&ml, NeoMutt, MUTT_NOTMUCH);
    struct MailboxNode *mp = STAILQ_FIRST(&ml);
    if (mp)
      cs_str_string_set(cs, "spool_file", mailbox_path(mp->mailbox), NULL);
    neomutt_mailboxlist_clear(&ml);
  }
#endif
  rc = 0;
 
done:
  buf_dealloc(&err);
  buf_dealloc(&buf);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_opts_cleanup()

void mutt_opts_cleanup

(

void

)

Clean up before quitting.

Definition at line 265 of file init.c.

{
  source_stack_cleanup();
 
  alias_cleanup();
#ifdef USE_SIDEBAR
  sb_cleanup();
#endif
 
  mutt_regexlist_free(&MailLists);
  mutt_regexlist_free(&NoSpamList);
  mutt_regexlist_free(&SubscribedLists);
  mutt_regexlist_free(&UnMailLists);
  mutt_regexlist_free(&UnSubscribedLists);
 
  mutt_grouplist_cleanup();
  driver_tags_cleanup();
 
  /* Lists of strings */
  mutt_list_free(&AlternativeOrderList);
  mutt_list_free(&AutoViewList);
  mutt_list_free(&HeaderOrderList);
  mutt_list_free(&Ignore);
  mutt_list_free(&MailToAllow);
  mutt_list_free(&MimeLookupList);
  mutt_list_free(&Muttrc);
  mutt_list_free(&UnIgnore);
  mutt_list_free(&UserHeader);
 
  mutt_colors_cleanup();
 
  FREE(&CurrentFolder);
  FREE(&HomeDir);
  FREE(&LastFolder);
  FREE(&ShortHostname);
  FREE(&Username);
 
  mutt_replacelist_free(&SpamList);
 
  mutt_delete_hooks(MUTT_HOOK_NO_FLAGS);
 
  mutt_hist_cleanup();
  mutt_keys_cleanup();
 
  mutt_regexlist_free(&NoSpamList);
  commands_cleanup();
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_query_variables()

int mutt_query_variables	(	struct ListHead *	queries,
		bool	show_docs
	)

Implement the -Q command line flag.

Parameters

queries	List of query strings
show_docs	If true, show one-liner docs for the config item

Return values

0	Success, all queries exist
1	Error

Definition at line 617 of file init.c.

{
  struct Buffer value = buf_make(256);
  struct Buffer tmp = buf_make(256);
  int rc = 0;
 
  struct ListNode *np = NULL;
  STAILQ_FOREACH(np, queries, entries)
  {
    buf_reset(&value);
 
    struct HashElem *he = cs_subset_lookup(NeoMutt->sub, np->data);
    if (he)
    {
      if (he->type & DT_DEPRECATED)
      {
        mutt_warning(_("Config variable '%s' is deprecated"), np->data);
        rc = 1;
        continue;
      }
 
      int rv = cs_subset_he_string_get(NeoMutt->sub, he, &value);
      if (CSR_RESULT(rv) != CSR_SUCCESS)
      {
        rc = 1;
        continue;
      }
 
      int type = DTYPE(he->type);
      if (type == DT_PATH)
        mutt_pretty_mailbox(value.data, value.dsize);
 
      if ((type != DT_BOOL) && (type != DT_NUMBER) && (type != DT_LONG) && (type != DT_QUAD))
      {
        buf_reset(&tmp);
        pretty_var(value.data, &tmp);
        buf_strcpy(&value, tmp.data);
      }
 
      dump_config_neo(NeoMutt->sub->cs, he, &value, NULL,
                      show_docs ? CS_DUMP_SHOW_DOCS : CS_DUMP_NO_FLAGS, stdout);
      continue;
    }
 
    mutt_warning(_("No such variable: %s"), np->data);
    rc = 1;
  }
 
  buf_dealloc(&value);
  buf_dealloc(&tmp);
 
  return rc; // TEST16: neomutt -Q charset
}

Here is the call graph for this function:

Here is the caller graph for this function: