init.c File Reference

Config/command parsing. More...

#include "config.h"
#include <ctype.h>
#include <inttypes.h>
#include <pwd.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/utsname.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 "conn/lib.h"
#include "gui/lib.h"
#include "mutt.h"
#include "init.h"
#include "alias.h"
#include "command_parse.h"
#include "context.h"
#include "functions.h"
#include "globals.h"
#include "keymap.h"
#include "mutt_commands.h"
#include "mutt_config.h"
#include "mutt_menu.h"
#include "mutt_parse.h"
#include "muttlib.h"
#include "myvar.h"
#include "options.h"
#include "protos.h"
#include "sort.h"
#include "compress/lib.h"
#include "history/lib.h"
#include "store/lib.h"
#include "hcache/lib.h"
#include "notmuch/lib.h"

Include dependency graph for init.c:

Go to the source code of this file.

Functions
static void	matches_ensure_morespace (int current)
	Allocate more space for auto-completion. More...
static void	candidate (char *user, const char *src, char *dest, size_t dlen)
	helper function for completion More...
static int	complete_all_nm_tags (const char *pt)
	Pass a list of Notmuch tags to the completion code. More...
static int	execute_commands (struct ListHead *p)
	Execute a set of NeoMutt commands. More...
static char *	find_cfg (const char *home, const char *xdg_cfg_home)
	Find a config file. More...
static char *	getmailname (void)
	Try to retrieve the FQDN from mailname files. More...
static bool	get_hostname (struct ConfigSet *cs)
	Find the Fully-Qualified Domain Name. More...
const struct Command *	mutt_command_get (const char *s)
	Get a Command by its name. More...
void	mutt_commands_apply (void *data, void(*application)(void *, const struct Command *))
	Run a callback function on every Command. More...
int	mutt_extract_token (struct Buffer *dest, struct Buffer *tok, TokenFlags flags)
	Extract one token from a string. More...
void	mutt_opts_free (void)
	clean up before quitting More...
HookFlags	mutt_get_hook_type (const char *name)
	Find a hook by name. More...
int	mutt_init (struct ConfigSet *cs, bool skip_sys_rc, struct ListHead *commands)
	Initialise NeoMutt. More...
enum CommandResult	mutt_parse_rc_line (char *line, struct Buffer *token, struct Buffer *err)
	Parse a line of user config. More...
int	mutt_query_variables (struct ListHead *queries)
	Implement the -Q command line flag. More...
enum QuadOption	query_quadoption (enum QuadOption opt, const char *prompt)
	Ask the user a quad-question. More...
int	mutt_command_complete (char *buf, size_t buflen, int pos, int numtabs)
	Complete a command name. More...
int	mutt_label_complete (char *buf, size_t buflen, int numtabs)
	Complete a label name. More...
bool	mutt_nm_query_complete (char *buf, size_t buflen, int pos, int numtabs)
	Complete to the nearest notmuch tag. More...
bool	mutt_nm_tag_complete (char *buf, size_t buflen, int numtabs)
	Complete to the nearest notmuch tag. More...
int	mutt_var_value_complete (char *buf, size_t buflen, int pos)
	Complete a variable/value. More...
struct ConfigSet *	init_config (size_t size)
	Initialise the config system. More...
int	charset_validator (const struct ConfigSet *cs, const struct ConfigDef *cdef, intptr_t value, struct Buffer *err)
	Validate the "charset" config variable - Implements ConfigDef::validator() More...
int	hcache_validator (const struct ConfigSet *cs, const struct ConfigDef *cdef, intptr_t value, struct Buffer *err)
	Validate the "header_cache_backend" config variable - Implements ConfigDef::validator() More...
int	compress_validator (const struct ConfigSet *cs, const struct ConfigDef *cdef, intptr_t value, struct Buffer *err)
	Validate the "header_cache_compress_method" config variable - Implements ConfigDef::validator() More...
int	pager_validator (const struct ConfigSet *cs, const struct ConfigDef *cdef, intptr_t value, struct Buffer *err)
	Check for config variables that can't be set from the pager - Implements ConfigDef::validator() More...
int	multipart_validator (const struct ConfigSet *cs, const struct ConfigDef *cdef, intptr_t value, struct Buffer *err)
	Validate the "show_multipart_alternative" config variable - Implements ConfigDef::validator() More...
int	reply_validator (const struct ConfigSet *cs, const struct ConfigDef *cdef, intptr_t value, struct Buffer *err)
	Validate the "reply_regex" config variable - Implements ConfigDef::validator() More...
int	wrapheaders_validator (const struct ConfigSet *cs, const struct ConfigDef *cdef, intptr_t value, struct Buffer *err)
	Validate the "wrap_headers" config variable - Implements ConfigDef::validator() More...

Variables
static char	UserTyped [1024] = { 0 }
static int	NumMatched = 0
static char	Completed [256] = { 0 }
static const char **	Matches
static int	MatchesListsize = 512
static char **	nm_tags

Detailed Description

Config/command parsing.

Authors

• Michael R. Elkins
• Pietro Cerutti

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

Function Documentation

matches_ensure_morespace()

static void matches_ensure_morespace ( int  current )

static

Allocate more space for auto-completion.

Parameters

current

Current allocation

Definition at line 94 of file init.c.

{
  if (current <= (MatchesListsize - 2))
    return;

  int base_space = 512; // Enough space for all of the config items
  int extra_space = MatchesListsize - base_space;
  extra_space *= 2;
  const int space = base_space + extra_space;
  mutt_mem_realloc(&Matches, space * sizeof(char *));
  memset(&Matches[current + 1], 0, space - current);
  MatchesListsize = space;
}

Here is the call graph for this function:

Here is the caller graph for this function:

candidate()

static void candidate ( char *  user, const char *  src, char *  dest, size_t  dlen  )

static

helper function for completion

Parameters

user	User entered data for completion
src	Candidate for completion
dest	Completion result gets here
dlen	Length of dest buffer

Changes the dest buffer if necessary/possible to aid completion.

Definition at line 117 of file init.c.

{
  if (!dest || !user || !src)
    return;

  if (strstr(src, user) != src)
    return;

  matches_ensure_morespace(NumMatched);
  Matches[NumMatched++] = src;
  if (dest[0] == '\0')
    mutt_str_strfcpy(dest, src, dlen);
  else
  {
    int l;
    for (l = 0; src[l] && src[l] == dest[l]; l++)
      ;
    dest[l] = '\0';
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

complete_all_nm_tags()

static int complete_all_nm_tags ( const char *  pt )

static

Pass a list of Notmuch tags to the completion code.

Parameters

pt	List of all Notmuch tags

Return values

0	Success
-1	Error

Definition at line 145 of file init.c.

{
  int tag_count_1 = 0;
  int tag_count_2 = 0;

  NumMatched = 0;
  mutt_str_strfcpy(UserTyped, pt, sizeof(UserTyped));
  memset(Matches, 0, MatchesListsize);
  memset(Completed, 0, sizeof(Completed));

  nm_db_longrun_init(Context->mailbox, false);

  /* Work out how many tags there are. */
  if (nm_get_all_tags(Context->mailbox, NULL, &tag_count_1) || (tag_count_1 == 0))
    goto done;

  /* Free the old list, if any. */
  if (nm_tags)
  {
    for (int i = 0; nm_tags[i]; i++)
      FREE(&nm_tags[i]);
    FREE(&nm_tags);
  }
  /* Allocate a new list, with sentinel. */
  nm_tags = mutt_mem_malloc((tag_count_1 + 1) * sizeof(char *));
  nm_tags[tag_count_1] = NULL;

  /* Get all the tags. */
  if (nm_get_all_tags(Context->mailbox, nm_tags, &tag_count_2) || (tag_count_1 != tag_count_2))
  {
    FREE(&nm_tags);
    nm_tags = NULL;
    nm_db_longrun_done(Context->mailbox);
    return -1;
  }

  /* Put them into the completion machinery. */
  for (int num = 0; num < tag_count_1; num++)
  {
    candidate(UserTyped, nm_tags[num], Completed, sizeof(Completed));
  }

  matches_ensure_morespace(NumMatched);
  Matches[NumMatched++] = UserTyped;

done:
  nm_db_longrun_done(Context->mailbox);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

execute_commands()

static int execute_commands ( struct ListHead *  p )

static

Execute a set of NeoMutt commands.

Parameters

p	List of command strings

Return values

0	Success, all the commands succeeded
-1	Error

Definition at line 202 of file init.c.

{
  int rc = 0;
  struct Buffer *err = mutt_buffer_pool_get();
  struct Buffer *token = mutt_buffer_pool_get();

  struct ListNode *np = NULL;
  STAILQ_FOREACH(np, p, entries)
  {
    enum CommandResult rc2 = mutt_parse_rc_line(np->data, token, err);
    if (rc2 == MUTT_CMD_ERROR)
      mutt_error(_("Error in command line: %s"), mutt_b2s(err));
    else if (rc2 == MUTT_CMD_WARNING)
      mutt_warning(_("Warning in command line: %s"), mutt_b2s(err));

    if ((rc2 == MUTT_CMD_ERROR) || (rc2 == MUTT_CMD_WARNING))
    {
      mutt_buffer_pool_release(&token);
      mutt_buffer_pool_release(&err);
      return -1;
    }
  }
  mutt_buffer_pool_release(&token);
  mutt_buffer_pool_release(&err);

  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 237 of file init.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 },
  };

  for (int i = 0; locations[i][0] || locations[i][1]; i++)
  {
    if (!locations[i][0])
      continue;

    for (int j = 0; names[j]; j++)
    {
      char buf[256];

      snprintf(buf, sizeof(buf), "%s/%s%s", locations[i][0], locations[i][1], names[j]);
      if (access(buf, F_OK) == 0)
        return mutt_str_strdup(buf);
    }
  }

  return NULL;
}

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	if no valid mailname file could be read

Definition at line 278 of file init.c.

{
  char *mailname = NULL;
  static const char *mn_files[] = { "/etc/mailname", "/etc/mail/mailname" };

  for (size_t i = 0; i < mutt_array_size(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, 0);
    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.

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 310 of file init.c.

{
  char *str = NULL;
  struct utsname utsname;

  if (C_Hostname)
  {
    str = 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
    }

    str = utsname.nodename;
  }

  /* some systems report the FQDN instead of just the hostname */
  char *dot = strchr(str, '.');
  if (dot)
    ShortHostname = mutt_str_substr_dup(str, dot);
  else
    ShortHostname = mutt_str_strdup(str);

  if (!C_Hostname)
  {
    /* now get FQDN.  Use configured domain first, DNS next, then uname */
#ifdef DOMAIN
    /* we have a compile-time domain name, use that for C_Hostname */
    C_Hostname =
        mutt_mem_malloc(mutt_str_strlen(DOMAIN) + mutt_str_strlen(ShortHostname) + 2);
    sprintf((char *) C_Hostname, "%s.%s", NONULL(ShortHostname), DOMAIN);
#else
    C_Hostname = getmailname();
    if (!C_Hostname)
    {
      char buffer[1024];
      if (getdnsdomainname(buffer, sizeof(buffer)) == 0)
      {
        C_Hostname = mutt_mem_malloc(mutt_str_strlen(buffer) +
                                     mutt_str_strlen(ShortHostname) + 2);
        sprintf((char *) C_Hostname, "%s.%s", NONULL(ShortHostname), buffer);
      }
      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.  */
        C_Hostname = mutt_str_strdup(utsname.nodename);
      }
    }
#endif
  }
  if (C_Hostname)
    cs_str_initial_set(cs, "hostname", C_Hostname, NULL);

  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_command_get()

const struct Command* mutt_command_get

(

const char *

s

)

Get a Command by its name.

Parameters

s	Command string to lookup

Return values

ptr	Success, Command
NULL	Error, no such command

Definition at line 385 of file init.c.

{
  for (int i = 0; Commands[i].name; i++)
    if (mutt_str_strcmp(s, Commands[i].name) == 0)
      return &Commands[i];
  return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_commands_apply()

void mutt_commands_apply	(	void *	data,
		void(*)(void *, const struct Command *)	application
	)

Run a callback function on every Command.

Parameters

data	Data to pass to the callback function
application	Callback function

This is used by Lua to expose all of NeoMutt's Commands.

Definition at line 401 of file init.c.

{
  for (int i = 0; Commands[i].name; i++)
    application(data, &Commands[i]);
}

Here is the caller graph for this function:

mutt_extract_token()

int mutt_extract_token	(	struct Buffer *	dest,
		struct Buffer *	tok,
		TokenFlags	flags
	)

Extract one token from a string.

Parameters

dest	Buffer for the result
tok	Buffer containing tokens
flags	Flags, see TokenFlags

Return values

0	Success
-1	Error

Definition at line 416 of file init.c.

{
  if (!dest || !tok)
    return -1;

  char ch;
  char qc = '\0'; /* quote char */
  char *pc = NULL;

  mutt_buffer_reset(dest);

  SKIPWS(tok->dptr);
  while ((ch = *tok->dptr))
  {
    if (qc == '\0')
    {
      if ((IS_SPACE(ch) && !(flags & MUTT_TOKEN_SPACE)) ||
          ((ch == '#') && !(flags & MUTT_TOKEN_COMMENT)) ||
          ((ch == '=') && (flags & MUTT_TOKEN_EQUAL)) ||
          ((ch == '?') && (flags & MUTT_TOKEN_QUESTION)) ||
          ((ch == ';') && !(flags & MUTT_TOKEN_SEMICOLON)) ||
          ((flags & MUTT_TOKEN_PATTERN) && strchr("~%=!|", ch)))
      {
        break;
      }
    }

    tok->dptr++;

    if (ch == qc)
      qc = 0; /* end of quote */
    else if (!qc && ((ch == '\'') || (ch == '"')) && !(flags & MUTT_TOKEN_QUOTE))
      qc = ch;
    else if ((ch == '\\') && (qc != '\''))
    {
      if (tok->dptr[0] == '\0')
        return -1; /* premature end of token */
      switch (ch = *tok->dptr++)
      {
        case 'c':
        case 'C':
          if (tok->dptr[0] == '\0')
            return -1; /* premature end of token */
          mutt_buffer_addch(dest, (toupper((unsigned char) tok->dptr[0]) - '@') & 0x7f);
          tok->dptr++;
          break;
        case 'e':
          mutt_buffer_addch(dest, '\033'); // Escape
          break;
        case 'f':
          mutt_buffer_addch(dest, '\f');
          break;
        case 'n':
          mutt_buffer_addch(dest, '\n');
          break;
        case 'r':
          mutt_buffer_addch(dest, '\r');
          break;
        case 't':
          mutt_buffer_addch(dest, '\t');
          break;
        default:
          if (isdigit((unsigned char) ch) && isdigit((unsigned char) tok->dptr[0]) &&
              isdigit((unsigned char) tok->dptr[1]))
          {
            mutt_buffer_addch(dest, (ch << 6) + (tok->dptr[0] << 3) + tok->dptr[1] - 3504);
            tok->dptr += 2;
          }
          else
            mutt_buffer_addch(dest, ch);
      }
    }
    else if ((ch == '^') && (flags & MUTT_TOKEN_CONDENSE))
    {
      if (tok->dptr[0] == '\0')
        return -1; /* premature end of token */
      ch = *tok->dptr++;
      if (ch == '^')
        mutt_buffer_addch(dest, ch);
      else if (ch == '[')
        mutt_buffer_addch(dest, '\033'); // Escape
      else if (isalpha((unsigned char) ch))
        mutt_buffer_addch(dest, toupper((unsigned char) ch) - '@');
      else
      {
        mutt_buffer_addch(dest, '^');
        mutt_buffer_addch(dest, ch);
      }
    }
    else if ((ch == '`') && (!qc || (qc == '"')))
    {
      FILE *fp = NULL;
      pid_t pid;
      int line = 0;

      pc = tok->dptr;
      do
      {
        pc = strpbrk(pc, "\\`");
        if (pc)
        {
          /* skip any quoted chars */
          if (*pc == '\\')
            pc += 2;
        }
      } while (pc && (pc[0] != '`'));
      if (!pc)
      {
        mutt_debug(LL_DEBUG1, "mismatched backticks\n");
        return -1;
      }
      struct Buffer cmd;
      mutt_buffer_init(&cmd);
      *pc = '\0';
      if (flags & MUTT_TOKEN_BACKTICK_VARS)
      {
        /* recursively extract tokens to interpolate variables */
        mutt_extract_token(&cmd, tok,
                           MUTT_TOKEN_QUOTE | MUTT_TOKEN_SPACE | MUTT_TOKEN_COMMENT |
                               MUTT_TOKEN_SEMICOLON | MUTT_TOKEN_NOSHELL);
      }
      else
      {
        cmd.data = mutt_str_strdup(tok->dptr);
      }
      *pc = '`';
      pid = filter_create(cmd.data, NULL, &fp, NULL);
      if (pid < 0)
      {
        mutt_debug(LL_DEBUG1, "unable to fork command: %s\n", cmd.data);
        FREE(&cmd.data);
        return -1;
      }
      FREE(&cmd.data);

      tok->dptr = pc + 1;

      /* read line */
      struct Buffer expn = mutt_buffer_make(0);
      expn.data = mutt_file_read_line(NULL, &expn.dsize, fp, &line, 0);
      mutt_file_fclose(&fp);
      filter_wait(pid);

      /* if we got output, make a new string consisting of the shell output
       * plus whatever else was left on the original line */
      /* BUT: If this is inside a quoted string, directly add output to
       * the token */
      if (expn.data)
      {
        if (qc)
        {
          mutt_buffer_addstr(dest, expn.data);
        }
        else
        {
          struct Buffer *copy = mutt_buffer_pool_get();
          mutt_buffer_fix_dptr(&expn);
          mutt_buffer_copy(copy, &expn);
          mutt_buffer_addstr(copy, tok->dptr);
          mutt_buffer_copy(tok, copy);
          tok->dptr = tok->data;
          mutt_buffer_pool_release(&copy);
        }
        FREE(&expn.data);
      }
    }
    else if ((ch == '$') && (!qc || (qc == '"')) &&
             ((tok->dptr[0] == '{') || isalpha((unsigned char) tok->dptr[0])))
    {
      const char *env = NULL;
      char *var = NULL;

      if (tok->dptr[0] == '{')
      {
        pc = strchr(tok->dptr, '}');
        if (pc)
        {
          var = mutt_str_substr_dup(tok->dptr + 1, pc);
          tok->dptr = pc + 1;

          if ((flags & MUTT_TOKEN_NOSHELL))
          {
            mutt_buffer_addch(dest, ch);
            mutt_buffer_addch(dest, '{');
            mutt_buffer_addstr(dest, var);
            mutt_buffer_addch(dest, '}');
            FREE(&var);
          }
        }
      }
      else
      {
        for (pc = tok->dptr; isalnum((unsigned char) *pc) || (pc[0] == '_'); pc++)
          ;
        var = mutt_str_substr_dup(tok->dptr, pc);
        tok->dptr = pc;
      }
      if (var)
      {
        struct Buffer result;
        mutt_buffer_init(&result);
        int rc = cs_subset_str_string_get(NeoMutt->sub, var, &result);

        if (CSR_RESULT(rc) == CSR_SUCCESS)
        {
          mutt_buffer_addstr(dest, result.data);
          FREE(&result.data);
        }
        else if ((env = myvar_get(var)))
        {
          mutt_buffer_addstr(dest, env);
        }
        else if (!(flags & MUTT_TOKEN_NOSHELL) && (env = mutt_str_getenv(var)))
        {
          mutt_buffer_addstr(dest, env);
        }
        else
        {
          mutt_buffer_addch(dest, ch);
          mutt_buffer_addstr(dest, var);
        }
        FREE(&var);
      }
    }
    else
      mutt_buffer_addch(dest, ch);
  }
  mutt_buffer_addch(dest, 0); /* terminate the string */
  SKIPWS(tok->dptr);
  return 0;
}

mutt_opts_free()

void mutt_opts_free

(

void

)

clean up before quitting

Definition at line 651 of file init.c.

{
  clear_source_stack();

  mutt_aliaslist_free(&Aliases);

  mutt_regexlist_free(&Alternates);
  mutt_regexlist_free(&MailLists);
  mutt_regexlist_free(&NoSpamList);
  mutt_regexlist_free(&SubscribedLists);
  mutt_regexlist_free(&UnAlternates);
  mutt_regexlist_free(&UnMailLists);
  mutt_regexlist_free(&UnSubscribedLists);

  mutt_grouplist_free();
  mutt_hash_free(&ReverseAliases);
  mutt_hash_free(&TagFormats);
  mutt_hash_free(&TagTransforms);

  /* 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);
#ifdef USE_SIDEBAR
  mutt_list_free(&SidebarWhitelist);
#endif
  mutt_list_free(&UnIgnore);
  mutt_list_free(&UserHeader);

  /* Lists of AttachMatch */
  mutt_list_free_type(&AttachAllow, (list_free_t) mutt_attachmatch_free);
  mutt_list_free_type(&AttachExclude, (list_free_t) mutt_attachmatch_free);
  mutt_list_free_type(&InlineAllow, (list_free_t) mutt_attachmatch_free);
  mutt_list_free_type(&InlineExclude, (list_free_t) mutt_attachmatch_free);

  mutt_colors_free(&Colors);

  FREE(&CurrentFolder);
  FREE(&HomeDir);
  FREE(&LastFolder);
  FREE(&ShortHostname);
  FREE(&Username);

  mutt_replacelist_free(&SpamList);
  mutt_replacelist_free(&SubjectRegexList);

  mutt_delete_hooks(MUTT_HOOK_NO_FLAGS);

  mutt_hist_free();
  mutt_keys_free();

  mutt_regexlist_free(&NoSpamList);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_get_hook_type()

HookFlags mutt_get_hook_type

(

const char *

name

)

Find a hook by name.

Parameters

name	Name to find

Return values

num	Hook ID, e.g. MUTT_FOLDER_HOOK
MUTT_HOOK_NO_FLAGS	Error, no matching hook

Definition at line 715 of file init.c.

{
  for (const struct Command *c = Commands; c->name; c++)
  {
    if (((c->parse == mutt_parse_hook) || (c->parse == mutt_parse_idxfmt_hook)) &&
        (mutt_str_strcasecmp(c->name, name) == 0))
    {
      return c->data;
    }
  }
  return MUTT_HOOK_NO_FLAGS;
}

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 736 of file init.c.

{
  char buf[1024];
  int need_pause = 0;
  int rc = 1;
  struct Buffer err = mutt_buffer_make(256);

  mutt_grouplist_init();
  /* reverse alias keys need to be strdup'ed because of idna conversions */
  ReverseAliases = mutt_hash_new(1031, MUTT_HASH_STRCASECMP | MUTT_HASH_STRDUP_KEYS |
                                           MUTT_HASH_ALLOW_DUPS);
  TagTransforms = mutt_hash_new(64, MUTT_HASH_STRCASECMP);
  TagFormats = mutt_hash_new(64, MUTT_HASH_NO_FLAGS);

  mutt_menu_init();

  snprintf(AttachmentMarker, sizeof(AttachmentMarker), "\033]9;%" PRIu64 "\a", // Escape
           mutt_rand64());

  snprintf(ProtectedHeaderMarker, sizeof(ProtectedHeaderMarker), "\033]8;%lld\a", // Escape
           (long long) mutt_date_epoch());

  /* "$spoolfile" precedence: config file, environment */
  const char *p = mutt_str_getenv("MAIL");
  if (!p)
    p = mutt_str_getenv("MAILDIR");
  if (!p)
  {
#ifdef HOMESPOOL
    mutt_path_concat(buf, NONULL(HomeDir), MAILPATH, sizeof(buf));
#else
    mutt_path_concat(buf, MAILPATH, NONULL(Username), sizeof(buf));
#endif
    p = buf;
  }
  cs_str_initial_set(cs, "spoolfile", p, NULL);
  cs_str_reset(cs, "spoolfile", NULL);

  p = mutt_str_getenv("REPLYTO");
  if (p)
  {
    struct Buffer tmp, token;

    snprintf(buf, sizeof(buf), "Reply-To: %s", p);

    mutt_buffer_init(&tmp);
    tmp.data = buf;
    tmp.dptr = buf;
    tmp.dsize = mutt_str_strlen(buf);

    mutt_buffer_init(&token);
    parse_my_hdr(&token, &tmp, 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_string_set(cs, "mailcap_path", env_mc, NULL);

  /* "$tmpdir" precedence: config file, environment, code */
  const char *env_tmp = mutt_str_getenv("TMPDIR");
  if (env_tmp)
    cs_str_string_set(cs, "tmpdir", env_tmp, 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)
  {
    cs_str_string_set(cs, "editor", env_ed, NULL);
    cs_str_string_set(cs, "visual", env_ed, NULL);
  }

  C_Charset = mutt_ch_get_langinfo_charset();
  cs_str_initial_set(cs, "charset", C_Charset, NULL);
  mutt_ch_set_charset(C_Charset);

  Matches = mutt_mem_calloc(MatchesListsize, sizeof(char *));

  CurrentMenu = MENU_MAIN;

#ifdef HAVE_GETSID
  /* Unset suspend by default if we're the session leader */
  if (getsid(0) == getpid())
    C_Suspend = false;
#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)
    {
      snprintf(buf, sizeof(buf), "%s/.config", HomeDir);
      xdg_cfg_home = 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)
    {
      mutt_str_strfcpy(buf, np->data, sizeof(buf));
      FREE(&np->data);
      mutt_expand_path(buf, sizeof(buf));
      np->data = mutt_str_strdup(buf);
      if (access(np->data, F_OK))
      {
        mutt_perror(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, sizeof(buf)))
        break;

      snprintf(buf, sizeof(buf), "%s/neomuttrc", SYSCONFDIR);
      if (access(buf, F_OK) == 0)
        break;

      snprintf(buf, sizeof(buf), "%s/Muttrc", SYSCONFDIR);
      if (access(buf, F_OK) == 0)
        break;

      snprintf(buf, sizeof(buf), "%s/neomuttrc", PKGDATADIR);
      if (access(buf, F_OK) == 0)
        break;

      snprintf(buf, sizeof(buf), "%s/Muttrc", PKGDATADIR);
    } while (false);

    if (access(buf, F_OK) == 0)
    {
      if (source_rc(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;

  if (!C_Realname)
  {
    struct passwd *pw = getpwuid(getuid());
    if (pw)
    {
      char name[256];
      C_Realname = mutt_str_strdup(mutt_gecos_name(name, sizeof(name), pw));
    }
  }
  cs_str_initial_set(cs, "realname", C_Realname, 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')
  }

  mutt_file_mkdir(C_Tmpdir, S_IRWXU);

  mutt_hist_init();
  mutt_hist_read_file();

#ifdef USE_NOTMUCH
  if (C_VirtualSpoolfile)
  {
    /* Find the first virtual folder and open it */
    struct MailboxList ml = neomutt_mailboxlist_get_all(NeoMutt, MUTT_NOTMUCH);
    struct MailboxNode *mp = STAILQ_FIRST(&ml);
    if (mp)
      cs_str_string_set(cs, "spoolfile", mailbox_path(mp->mailbox), NULL);
    neomutt_mailboxlist_clear(&ml);
  }
#endif
  rc = 0;

done:
  FREE(&err.data);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_parse_rc_line()

enum CommandResult mutt_parse_rc_line	(	char *	line,
		struct Buffer *	token,
		struct Buffer *	err
	)

Parse a line of user config.

Parameters

line	config line to read
token	scratch buffer to be used by parser
err	where to write error messages

Return values

CommandResult

Result e.g. MUTT_CMD_SUCCESS

Caller should free token->data when finished. the reason for this variable is to avoid having to allocate and deallocate a lot of memory if we are parsing many lines. the caller can pass in the memory to use, which avoids having to create new space for every call to this function.

Definition at line 991 of file init.c.

{
  if (!line || !*line)
    return 0;

  int i;
  enum CommandResult rc = MUTT_CMD_SUCCESS;

  struct Buffer expn = mutt_buffer_make(128);
  mutt_buffer_addstr(&expn, line);
  expn.dptr = expn.data;

  *err->data = 0;

  SKIPWS(expn.dptr);
  while (*expn.dptr != '\0')
  {
    if (*expn.dptr == '#')
      break; /* rest of line is a comment */
    if (*expn.dptr == ';')
    {
      expn.dptr++;
      continue;
    }
    mutt_extract_token(token, &expn, MUTT_TOKEN_NO_FLAGS);
    for (i = 0; Commands[i].name; i++)
    {
      if (mutt_str_strcmp(token->data, Commands[i].name) == 0)
      {
        rc = Commands[i].parse(token, &expn, Commands[i].data, err);
        if (rc != MUTT_CMD_SUCCESS)
        {              /* -1 Error, +1 Finish */
          goto finish; /* Propagate return code */
        }
        notify_send(NeoMutt->notify, NT_COMMAND, i, (void *) &Commands[i]);
        break; /* Continue with next command */
      }
    }
    if (!Commands[i].name)
    {
      mutt_buffer_printf(err, _("%s: unknown command"), NONULL(token->data));
      rc = MUTT_CMD_ERROR;
      break; /* Ignore the rest of the line */
    }
  }
finish:
  mutt_buffer_dealloc(&expn);
  return rc;
}

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

)

Implement the -Q command line flag.

Parameters

queries

List of query strings

Return values

0	Success, all queries exist
1	Error

Definition at line 1048 of file init.c.

{
  struct Buffer value = mutt_buffer_make(256);
  struct Buffer tmp = mutt_buffer_make(256);
  int rc = 0;

  struct ListNode *np = NULL;
  STAILQ_FOREACH(np, queries, entries)
  {
    mutt_buffer_reset(&value);

    struct HashElem *he = cs_subset_lookup(NeoMutt->sub, np->data);
    if (!he)
    {
      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))
    {
      mutt_buffer_reset(&tmp);
      pretty_var(value.data, &tmp);
      mutt_buffer_strcpy(&value, tmp.data);
    }

    dump_config_neo(NeoMutt->sub->cs, he, &value, NULL, CS_DUMP_NO_FLAGS, stdout);
  }

  mutt_buffer_dealloc(&value);
  mutt_buffer_dealloc(&tmp);

  return rc; // TEST16: neomutt -Q charset
}

Here is the call graph for this function:

Here is the caller graph for this function:

query_quadoption()

enum QuadOption query_quadoption	(	enum QuadOption	opt,
		const char *	prompt
	)

Ask the user a quad-question.

Parameters

opt	Option to use
prompt	Message to show to the user

Return values

QuadOption

Result, e.g. MUTT_NO

Definition at line 1099 of file init.c.

{
  switch (opt)
  {
    case MUTT_YES:
    case MUTT_NO:
      return opt;

    default:
      opt = mutt_yesorno(prompt, (opt == MUTT_ASKYES) ? MUTT_YES : MUTT_NO);
      mutt_window_clearline(MuttMessageWindow, 0);
      return opt;
  }

  /* not reached */
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_command_complete()

int mutt_command_complete	(	char *	buf,
		size_t	buflen,
		int	pos,
		int	numtabs
	)

Complete a command name.

Parameters

buf	Buffer for the result
buflen	Length of the buffer
pos	Cursor position in the buffer
numtabs	Number of times the user has hit 'tab'

Return values

1	Success, a match
0	Error, no match

Definition at line 1125 of file init.c.

{
  char *pt = buf;
  int num;
  int spaces; /* keep track of the number of leading spaces on the line */
  struct MyVar *myv = NULL;

  SKIPWS(buf);
  spaces = buf - pt;

  pt = buf + pos - spaces;
  while ((pt > buf) && !isspace((unsigned char) *pt))
    pt--;

  if (pt == buf) /* complete cmd */
  {
    /* first TAB. Collect all the matches */
    if (numtabs == 1)
    {
      NumMatched = 0;
      mutt_str_strfcpy(UserTyped, pt, sizeof(UserTyped));
      memset(Matches, 0, MatchesListsize);
      memset(Completed, 0, sizeof(Completed));
      for (num = 0; Commands[num].name; num++)
        candidate(UserTyped, Commands[num].name, Completed, sizeof(Completed));
      matches_ensure_morespace(NumMatched);
      Matches[NumMatched++] = UserTyped;

      /* All matches are stored. Longest non-ambiguous string is ""
       * i.e. don't change 'buf'. Fake successful return this time */
      if (UserTyped[0] == '\0')
        return 1;
    }

    if ((Completed[0] == '\0') && (UserTyped[0] != '\0'))
      return 0;

    /* NumMatched will _always_ be at least 1 since the initial
     * user-typed string is always stored */
    if ((numtabs == 1) && (NumMatched == 2))
      snprintf(Completed, sizeof(Completed), "%s", Matches[0]);
    else if ((numtabs > 1) && (NumMatched > 2))
    {
      /* cycle through all the matches */
      snprintf(Completed, sizeof(Completed), "%s", Matches[(numtabs - 2) % NumMatched]);
    }

    /* return the completed command */
    strncpy(buf, Completed, buflen - spaces);
  }
  else if (mutt_str_startswith(buf, "set", CASE_MATCH) ||
           mutt_str_startswith(buf, "unset", CASE_MATCH) ||
           mutt_str_startswith(buf, "reset", CASE_MATCH) ||
           mutt_str_startswith(buf, "toggle", CASE_MATCH))
  { /* complete variables */
    static const char *const prefixes[] = { "no", "inv", "?", "&", 0 };

    pt++;
    /* loop through all the possible prefixes (no, inv, ...) */
    if (mutt_str_startswith(buf, "set", CASE_MATCH))
    {
      for (num = 0; prefixes[num]; num++)
      {
        if (mutt_str_startswith(pt, prefixes[num], CASE_MATCH))
        {
          pt += mutt_str_strlen(prefixes[num]);
          break;
        }
      }
    }

    /* first TAB. Collect all the matches */
    if (numtabs == 1)
    {
      NumMatched = 0;
      mutt_str_strfcpy(UserTyped, pt, sizeof(UserTyped));
      memset(Matches, 0, MatchesListsize);
      memset(Completed, 0, sizeof(Completed));
      for (num = 0; MuttVars[num].name; num++)
        candidate(UserTyped, MuttVars[num].name, Completed, sizeof(Completed));
      TAILQ_FOREACH(myv, &MyVars, entries)
      {
        candidate(UserTyped, myv->name, Completed, sizeof(Completed));
      }
      matches_ensure_morespace(NumMatched);
      Matches[NumMatched++] = UserTyped;

      /* All matches are stored. Longest non-ambiguous string is ""
       * i.e. don't change 'buf'. Fake successful return this time */
      if (UserTyped[0] == '\0')
        return 1;
    }

    if ((Completed[0] == 0) && UserTyped[0])
      return 0;

    /* NumMatched will _always_ be at least 1 since the initial
     * user-typed string is always stored */
    if ((numtabs == 1) && (NumMatched == 2))
      snprintf(Completed, sizeof(Completed), "%s", Matches[0]);
    else if ((numtabs > 1) && (NumMatched > 2))
    {
      /* cycle through all the matches */
      snprintf(Completed, sizeof(Completed), "%s", Matches[(numtabs - 2) % NumMatched]);
    }

    strncpy(pt, Completed, buf + buflen - pt - spaces);
  }
  else if (mutt_str_startswith(buf, "exec", CASE_MATCH))
  {
    const struct Binding *menu = km_get_table(CurrentMenu);

    if (!menu && (CurrentMenu != MENU_PAGER))
      menu = OpGeneric;

    pt++;
    /* first TAB. Collect all the matches */
    if (numtabs == 1)
    {
      NumMatched = 0;
      mutt_str_strfcpy(UserTyped, pt, sizeof(UserTyped));
      memset(Matches, 0, MatchesListsize);
      memset(Completed, 0, sizeof(Completed));
      for (num = 0; menu[num].name; num++)
        candidate(UserTyped, menu[num].name, Completed, sizeof(Completed));
      /* try the generic menu */
      if ((Completed[0] == '\0') && (CurrentMenu != MENU_PAGER))
      {
        menu = OpGeneric;
        for (num = 0; menu[num].name; num++)
          candidate(UserTyped, menu[num].name, Completed, sizeof(Completed));
      }
      matches_ensure_morespace(NumMatched);
      Matches[NumMatched++] = UserTyped;

      /* All matches are stored. Longest non-ambiguous string is ""
       * i.e. don't change 'buf'. Fake successful return this time */
      if (UserTyped[0] == '\0')
        return 1;
    }

    if ((Completed[0] == '\0') && (UserTyped[0] != '\0'))
      return 0;

    /* NumMatched will _always_ be at least 1 since the initial
     * user-typed string is always stored */
    if ((numtabs == 1) && (NumMatched == 2))
      snprintf(Completed, sizeof(Completed), "%s", Matches[0]);
    else if ((numtabs > 1) && (NumMatched > 2))
    {
      /* cycle through all the matches */
      snprintf(Completed, sizeof(Completed), "%s", Matches[(numtabs - 2) % NumMatched]);
    }

    strncpy(pt, Completed, buf + buflen - pt - spaces);
  }
  else
    return 0;

  return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_label_complete()

int mutt_label_complete	(	char *	buf,
		size_t	buflen,
		int	numtabs
	)

Complete a label name.

Parameters

buf	Buffer for the result
buflen	Length of the buffer
numtabs	Number of times the user has hit 'tab'

Return values

1	Success, a match
0	Error, no match

Definition at line 1295 of file init.c.

{
  char *pt = buf;
  int spaces; /* keep track of the number of leading spaces on the line */

  if (!Context || !Context->mailbox->label_hash)
    return 0;

  SKIPWS(buf);
  spaces = buf - pt;

  /* first TAB. Collect all the matches */
  if (numtabs == 1)
  {
    struct HashElem *entry = NULL;
    struct HashWalkState state = { 0 };

    NumMatched = 0;
    mutt_str_strfcpy(UserTyped, buf, sizeof(UserTyped));
    memset(Matches, 0, MatchesListsize);
    memset(Completed, 0, sizeof(Completed));
    while ((entry = mutt_hash_walk(Context->mailbox->label_hash, &state)))
      candidate(UserTyped, entry->key.strkey, Completed, sizeof(Completed));
    matches_ensure_morespace(NumMatched);
    qsort(Matches, NumMatched, sizeof(char *), (sort_t) mutt_str_strcasecmp);
    Matches[NumMatched++] = UserTyped;

    /* All matches are stored. Longest non-ambiguous string is ""
     * i.e. don't change 'buf'. Fake successful return this time */
    if (UserTyped[0] == '\0')
      return 1;
  }

  if ((Completed[0] == '\0') && (UserTyped[0] != '\0'))
    return 0;

  /* NumMatched will _always_ be at least 1 since the initial
   * user-typed string is always stored */
  if ((numtabs == 1) && (NumMatched == 2))
    snprintf(Completed, sizeof(Completed), "%s", Matches[0]);
  else if ((numtabs > 1) && (NumMatched > 2))
  {
    /* cycle through all the matches */
    snprintf(Completed, sizeof(Completed), "%s", Matches[(numtabs - 2) % NumMatched]);
  }

  /* return the completed label */
  strncpy(buf, Completed, buflen - spaces);

  return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_nm_query_complete()

bool mutt_nm_query_complete	(	char *	buf,
		size_t	buflen,
		int	pos,
		int	numtabs
	)

Complete to the nearest notmuch tag.

Parameters

buf	Buffer for the result
buflen	Length of the buffer
pos	Cursor position in the buffer
numtabs	Number of times the user has hit 'tab'

Return values

true	Success, a match
false	Error, no match

Complete the nearest "tag:"-prefixed string previous to pos.

Definition at line 1359 of file init.c.

{
  char *pt = buf;
  int spaces;

  SKIPWS(buf);
  spaces = buf - pt;

  pt = (char *) mutt_str_rstrnstr((char *) buf, pos, "tag:");
  if (pt)
  {
    pt += 4;
    if (numtabs == 1)
    {
      /* First TAB. Collect all the matches */
      complete_all_nm_tags(pt);

      /* All matches are stored. Longest non-ambiguous string is ""
       * i.e. don't change 'buf'. Fake successful return this time.  */
      if (UserTyped[0] == '\0')
        return true;
    }

    if ((Completed[0] == '\0') && (UserTyped[0] != '\0'))
      return false;

    /* NumMatched will _always_ be at least 1 since the initial
     * user-typed string is always stored */
    if ((numtabs == 1) && (NumMatched == 2))
      snprintf(Completed, sizeof(Completed), "%s", Matches[0]);
    else if ((numtabs > 1) && (NumMatched > 2))
    {
      /* cycle through all the matches */
      snprintf(Completed, sizeof(Completed), "%s", Matches[(numtabs - 2) % NumMatched]);
    }

    /* return the completed query */
    strncpy(pt, Completed, buf + buflen - pt - spaces);
  }
  else
    return false;

  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_nm_tag_complete()

bool mutt_nm_tag_complete	(	char *	buf,
		size_t	buflen,
		int	numtabs
	)

Complete to the nearest notmuch tag.

Parameters

buf	Buffer for the result
buflen	Length of the buffer
numtabs	Number of times the user has hit 'tab'

Return values

true	Success, a match
false	Error, no match

Complete the nearest "+" or "-" -prefixed string previous to pos.

Definition at line 1416 of file init.c.

{
  if (!buf)
    return false;

  char *pt = buf;

  /* Only examine the last token */
  char *last_space = strrchr(buf, ' ');
  if (last_space)
    pt = (last_space + 1);

  /* Skip the +/- */
  if ((pt[0] == '+') || (pt[0] == '-'))
    pt++;

  if (numtabs == 1)
  {
    /* First TAB. Collect all the matches */
    complete_all_nm_tags(pt);

    /* All matches are stored. Longest non-ambiguous string is ""
     * i.e. don't change 'buf'. Fake successful return this time.  */
    if (UserTyped[0] == '\0')
      return true;
  }

  if ((Completed[0] == '\0') && (UserTyped[0] != '\0'))
    return false;

  /* NumMatched will _always_ be at least 1 since the initial
   * user-typed string is always stored */
  if ((numtabs == 1) && (NumMatched == 2))
    snprintf(Completed, sizeof(Completed), "%s", Matches[0]);
  else if ((numtabs > 1) && (NumMatched > 2))
  {
    /* cycle through all the matches */
    snprintf(Completed, sizeof(Completed), "%s", Matches[(numtabs - 2) % NumMatched]);
  }

  /* return the completed query */
  strncpy(pt, Completed, buf + buflen - pt);

  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_var_value_complete()

int mutt_var_value_complete	(	char *	buf,
		size_t	buflen,
		int	pos
	)

Complete a variable/value.

Parameters

buf	Buffer for the result
buflen	Length of the buffer
pos	Cursor position in the buffer

Definition at line 1469 of file init.c.

{
  char *pt = buf;

  if (buf[0] == '\0')
    return 0;

  SKIPWS(buf);
  const int spaces = buf - pt;

  pt = buf + pos - spaces;
  while ((pt > buf) && !isspace((unsigned char) *pt))
    pt--;
  pt++;           /* move past the space */
  if (*pt == '=') /* abort if no var before the '=' */
    return 0;

  if (mutt_str_startswith(buf, "set", CASE_MATCH))
  {
    const char *myvarval = NULL;
    char var[256];
    mutt_str_strfcpy(var, pt, sizeof(var));
    /* ignore the trailing '=' when comparing */
    int vlen = mutt_str_strlen(var);
    if (vlen == 0)
      return 0;

    var[vlen - 1] = '\0';

    struct HashElem *he = cs_subset_lookup(NeoMutt->sub, var);
    if (!he)
    {
      myvarval = myvar_get(var);
      if (myvarval)
      {
        struct Buffer pretty = mutt_buffer_make(256);
        pretty_var(myvarval, &pretty);
        snprintf(pt, buflen - (pt - buf), "%s=%s", var, pretty.data);
        mutt_buffer_dealloc(&pretty);
        return 1;
      }
      return 0; /* no such variable. */
    }
    else
    {
      struct Buffer value = mutt_buffer_make(256);
      struct Buffer pretty = mutt_buffer_make(256);
      int rc = cs_subset_he_string_get(NeoMutt->sub, he, &value);
      if (CSR_RESULT(rc) == CSR_SUCCESS)
      {
        pretty_var(value.data, &pretty);
        snprintf(pt, buflen - (pt - buf), "%s=%s", var, pretty.data);
        mutt_buffer_dealloc(&value);
        mutt_buffer_dealloc(&pretty);
        return 0;
      }
      mutt_buffer_dealloc(&value);
      mutt_buffer_dealloc(&pretty);
      return 1;
    }
  }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

init_config()

struct ConfigSet* init_config

(

size_t

size

)

Initialise the config system.

Parameters

size	Size for Config Hash Table

Return values

ptr	New Config Set

Definition at line 1538 of file init.c.

{
  struct ConfigSet *cs = cs_new(size);

  address_init(cs);
  bool_init(cs);
  enum_init(cs);
  long_init(cs);
  mbtable_init(cs);
  number_init(cs);
  path_init(cs);
  quad_init(cs);
  regex_init(cs);
  slist_init(cs);
  sort_init(cs);
  string_init(cs);

  if (!cs_register_variables(cs, MuttVars, 0))
  {
    mutt_error("cs_register_variables() failed");
    cs_free(&cs);
    return NULL;
  }

  return cs;
}

Here is the call graph for this function:

Here is the caller graph for this function:

charset_validator()

int charset_validator	(	const struct ConfigSet *	cs,
		const struct ConfigDef *	cdef,
		intptr_t	value,
		struct Buffer *	err
	)

Validate the "charset" config variable - Implements ConfigDef::validator()

Definition at line 1568 of file init.c.

{
  if (value == 0)
    return CSR_SUCCESS;

  const char *str = (const char *) value;

  if ((strcmp(cdef->name, "charset") == 0) && strchr(str, ':'))
  {
    mutt_buffer_printf(
        err, _("'charset' must contain exactly one character set name"));
    return CSR_ERR_INVALID;
  }

  int rc = CSR_SUCCESS;
  bool strict = (strcmp(cdef->name, "send_charset") == 0);
  char *q = NULL;
  char *s = mutt_str_strdup(str);

  for (char *p = strtok_r(s, ":", &q); p; p = strtok_r(NULL, ":", &q))
  {
    if (!*p)
      continue;
    if (!mutt_ch_check_charset(p, strict))
    {
      rc = CSR_ERR_INVALID;
      mutt_buffer_printf(err, _("Invalid value for option %s: %s"), cdef->name, p);
      break;
    }
  }

  FREE(&s);
  return rc;
}

Here is the call graph for this function:

hcache_validator()

int hcache_validator	(	const struct ConfigSet *	cs,
		const struct ConfigDef *	cdef,
		intptr_t	value,
		struct Buffer *	err
	)

Validate the "header_cache_backend" config variable - Implements ConfigDef::validator()

Definition at line 1608 of file init.c.

{
  if (value == 0)
    return CSR_SUCCESS;

  const char *str = (const char *) value;

  if (store_is_valid_backend(str))
    return CSR_SUCCESS;

  mutt_buffer_printf(err, _("Invalid value for option %s: %s"), cdef->name, str);
  return CSR_ERR_INVALID;
}

Here is the call graph for this function:

compress_validator()

int compress_validator	(	const struct ConfigSet *	cs,
		const struct ConfigDef *	cdef,
		intptr_t	value,
		struct Buffer *	err
	)

Validate the "header_cache_compress_method" config variable - Implements ConfigDef::validator()

Definition at line 1627 of file init.c.

{
  if (value == 0)
    return CSR_SUCCESS;

  const char *str = (const char *) value;

  if (compress_get_ops(str))
    return CSR_SUCCESS;

  mutt_buffer_printf(err, _("Invalid value for option %s: %s"), cdef->name, str);
  return CSR_ERR_INVALID;
}

Here is the call graph for this function:

pager_validator()

int pager_validator	(	const struct ConfigSet *	cs,
		const struct ConfigDef *	cdef,
		intptr_t	value,
		struct Buffer *	err
	)

Check for config variables that can't be set from the pager - Implements ConfigDef::validator()

Definition at line 1647 of file init.c.

{
  if (CurrentMenu == MENU_PAGER)
  {
    mutt_buffer_printf(err, _("Option %s may not be set or reset from the pager"),
                       cdef->name);
    return CSR_ERR_INVALID;
  }

  return CSR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

multipart_validator()

int multipart_validator	(	const struct ConfigSet *	cs,
		const struct ConfigDef *	cdef,
		intptr_t	value,
		struct Buffer *	err
	)

Validate the "show_multipart_alternative" config variable - Implements ConfigDef::validator()

Definition at line 1663 of file init.c.

{
  if (value == 0)
    return CSR_SUCCESS;

  const char *str = (const char *) value;

  if ((mutt_str_strcmp(str, "inline") == 0) || (mutt_str_strcmp(str, "info") == 0))
    return CSR_SUCCESS;

  mutt_buffer_printf(err, _("Invalid value for option %s: %s"), cdef->name, str);
  return CSR_ERR_INVALID;
}

Here is the call graph for this function:

reply_validator()

int reply_validator	(	const struct ConfigSet *	cs,
		const struct ConfigDef *	cdef,
		intptr_t	value,
		struct Buffer *	err
	)

Validate the "reply_regex" config variable - Implements ConfigDef::validator()

Definition at line 1681 of file init.c.

{
  if (pager_validator(cs, cdef, value, err) != CSR_SUCCESS)
    return CSR_ERR_INVALID;

  if (!OptAttachMsg)
    return CSR_SUCCESS;

  mutt_buffer_printf(err, _("Option %s may not be set when in attach-message mode"),
                     cdef->name);
  return CSR_ERR_INVALID;
}

Here is the call graph for this function:

wrapheaders_validator()

int wrapheaders_validator	(	const struct ConfigSet *	cs,
		const struct ConfigDef *	cdef,
		intptr_t	value,
		struct Buffer *	err
	)

Validate the "wrap_headers" config variable - Implements ConfigDef::validator()

Definition at line 1698 of file init.c.

{
  if ((value >= 78) && (value <= 998)) // Recommendation from RFC5233
    return CSR_SUCCESS;

  // L10N: This applies to the "$wrap_headers" config variable
  mutt_buffer_printf(err, _("Option %s must between 78 and 998 inclusive"), cdef->name);
  return CSR_ERR_INVALID;
}

Here is the call graph for this function:

Variable Documentation

UserTyped

char UserTyped[1024] = { 0 }

static

Definition at line 77 of file init.c.

NumMatched

int NumMatched = 0

static

Definition at line 79 of file init.c.

Completed

char Completed[256] = { 0 }

static

Definition at line 80 of file init.c.

Matches

const char** Matches

static

Definition at line 81 of file init.c.

MatchesListsize

int MatchesListsize = 512

static

Definition at line 83 of file init.c.

nm_tags

char** nm_tags

static

Definition at line 87 of file init.c.