init.c File Reference

Config/command parsing. More...

#include "config.h"
#include <ctype.h>
#include <errno.h>
#include <inttypes.h>
#include <limits.h>
#include <pwd.h>
#include <regex.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/mutt.h"
#include "address/lib.h"
#include "email/lib.h"
#include "core/lib.h"
#include "mutt.h"
#include "init.h"
#include "alias.h"
#include "context.h"
#include "filter.h"
#include "hcache/hcache.h"
#include "keymap.h"
#include "monitor.h"
#include "mutt_menu.h"
#include "mutt_parse.h"
#include "mutt_window.h"
#include "mx.h"
#include "myvar.h"
#include "options.h"
#include "protos.h"
#include "sidebar.h"
#include "version.h"
#include "notmuch/mutt_notmuch.h"
#include "imap/imap.h"
#include <libintl.h>

Include dependency graph for init.c:

Go to the source code of this file.

Macros
#define	MAX_ERRS   128
#define	NUM_VARS   mutt_array_size(MuttVars)
#define	NUM_COMMANDS   mutt_array_size(Commands)

Enumerations
enum	GroupState { GS_NONE, GS_RX, GS_ADDR }
	Type of email address group. More...

Functions
static void	add_to_stailq (struct ListHead *head, const char *str)
	Add a string to a list. More...
static void	alternates_clean (void)
	Clear the recipient valid flag of all emails. More...
static void	attachments_clean (void)
	always wise to do what someone else did before More...
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 void	clear_subject_mods (void)
	Clear out all modified email subjects. 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 (void)
	Find the Fully-Qualified Domain Name. More...
static struct AttachMatch *	mutt_attachmatch_new (void)
	Create a new AttachMatch. More...
static enum CommandResult	parse_attach_list (struct Buffer *buf, struct Buffer *s, struct ListHead *head, struct Buffer *err)
	Parse the "attachments" command. More...
static int	parse_grouplist (struct GroupList *gl, struct Buffer *buf, struct Buffer *s, unsigned long data, struct Buffer *err)
	Parse a group context. More...
static enum CommandResult	parse_replace_list (struct Buffer *buf, struct Buffer *s, unsigned long data, struct Buffer *err)
	Parse a string replacement rule - Implements command_t. More...
static enum CommandResult	parse_unattach_list (struct Buffer *buf, struct Buffer *s, struct ListHead *head, struct Buffer *err)
	Parse the "unattachments" command. More...
static enum CommandResult	parse_unreplace_list (struct Buffer *buf, struct Buffer *s, unsigned long data, struct Buffer *err)
	Remove a string replacement rule - Implements command_t. More...
static int	print_attach_list (struct ListHead *h, const char op, const char *name)
	Print a list of attachments. More...
static void	remove_from_stailq (struct ListHead *head, const char *str)
	Remove an item, matching a string, from a List. More...
static int	source_rc (const char *rcfile_path, struct Buffer *err)
	Read an initialization file. More...
static enum CommandResult	parse_alias (struct Buffer *buf, struct Buffer *s, unsigned long data, struct Buffer *err)
	Parse the 'alias' command - Implements command_t. More...
static enum CommandResult	parse_alternates (struct Buffer *buf, struct Buffer *s, unsigned long data, struct Buffer *err)
	Parse the 'alternates' command - Implements command_t. More...
static enum CommandResult	parse_attachments (struct Buffer *buf, struct Buffer *s, unsigned long data, struct Buffer *err)
	Parse the 'attachments' command - Implements command_t. More...
static enum CommandResult	parse_echo (struct Buffer *buf, struct Buffer *s, unsigned long data, struct Buffer *err)
	Parse the 'echo' command - Implements command_t. More...
static enum CommandResult	parse_finish (struct Buffer *buf, struct Buffer *s, unsigned long data, struct Buffer *err)
	Parse the 'finish' command - Implements command_t. More...
static enum CommandResult	parse_group (struct Buffer *buf, struct Buffer *s, unsigned long data, struct Buffer *err)
	Parse the 'group' and 'ungroup' commands - Implements command_t. More...
static bool	is_function (const char *name)
	Is the argument a neomutt function? More...
static enum CommandResult	parse_ifdef (struct Buffer *buf, struct Buffer *s, unsigned long data, struct Buffer *err)
	Parse the 'ifdef' and 'ifndef' commands - Implements command_t. More...
static enum CommandResult	parse_ignore (struct Buffer *buf, struct Buffer *s, unsigned long data, struct Buffer *err)
	Parse the 'ignore' command - Implements command_t. More...
static enum CommandResult	parse_lists (struct Buffer *buf, struct Buffer *s, unsigned long data, struct Buffer *err)
	Parse the 'lists' command - Implements command_t. More...
static enum CommandResult	parse_mailboxes (struct Buffer *buf, struct Buffer *s, unsigned long data, struct Buffer *err)
	Parse the 'mailboxes' command - Implements command_t. More...
static enum CommandResult	parse_my_hdr (struct Buffer *buf, struct Buffer *s, unsigned long data, struct Buffer *err)
	Parse the 'my_hdr' command - Implements command_t. More...
static enum CommandResult	parse_path_list (struct Buffer *buf, struct Buffer *s, unsigned long data, struct Buffer *err)
	Parse the 'sidebar_whitelist' command - Implements command_t. More...
static enum CommandResult	parse_path_unlist (struct Buffer *buf, struct Buffer *s, unsigned long data, struct Buffer *err)
	Parse the 'unsidebar_whitelist' command - Implements command_t. More...
static enum CommandResult	parse_set (struct Buffer *buf, struct Buffer *s, unsigned long data, struct Buffer *err)
	Parse the 'set' family of commands - Implements command_t. More...
static enum CommandResult	parse_setenv (struct Buffer *buf, struct Buffer *s, unsigned long data, struct Buffer *err)
	Parse the 'setenv' and 'unsetenv' commands - Implements command_t. More...
static enum CommandResult	parse_source (struct Buffer *buf, struct Buffer *s, unsigned long data, struct Buffer *err)
	Parse the 'source' command - Implements command_t. More...
static enum CommandResult	parse_spam_list (struct Buffer *buf, struct Buffer *s, unsigned long data, struct Buffer *err)
	Parse the 'spam' and 'nospam' commands - Implements command_t. More...
static enum CommandResult	parse_stailq (struct Buffer *buf, struct Buffer *s, unsigned long data, struct Buffer *err)
	Parse a list command - Implements command_t. More...
static enum CommandResult	parse_subjectrx_list (struct Buffer *buf, struct Buffer *s, unsigned long data, struct Buffer *err)
	Parse the 'subjectrx' command - Implements command_t. More...
static enum CommandResult	parse_subscribe (struct Buffer *buf, struct Buffer *s, unsigned long data, struct Buffer *err)
	Parse the 'subscribe' command - Implements command_t. More...
static enum CommandResult	parse_subscribe_to (struct Buffer *buf, struct Buffer *s, unsigned long data, struct Buffer *err)
	Parse the 'subscribe-to' command - Implements command_t. More...
static enum CommandResult	parse_tag_formats (struct Buffer *buf, struct Buffer *s, unsigned long data, struct Buffer *err)
	Parse the 'tag-formats' command - Implements command_t. More...
static enum CommandResult	parse_tag_transforms (struct Buffer *buf, struct Buffer *s, unsigned long data, struct Buffer *err)
	Parse the 'tag-transforms' command - Implements command_t. More...
static enum CommandResult	parse_unalias (struct Buffer *buf, struct Buffer *s, unsigned long data, struct Buffer *err)
	Parse the 'unalias' command - Implements command_t. More...
static enum CommandResult	parse_unalternates (struct Buffer *buf, struct Buffer *s, unsigned long data, struct Buffer *err)
	Parse the 'unalternates' command - Implements command_t. More...
void	mutt_attachmatch_free (struct AttachMatch **ptr)
	Free an AttachMatch - Implements list_free_t. More...
static enum CommandResult	parse_unattachments (struct Buffer *buf, struct Buffer *s, unsigned long data, struct Buffer *err)
	Parse the 'unattachments' command - Implements command_t. More...
static enum CommandResult	parse_unignore (struct Buffer *buf, struct Buffer *s, unsigned long data, struct Buffer *err)
	Parse the 'unignore' command - Implements command_t. More...
static enum CommandResult	parse_unlists (struct Buffer *buf, struct Buffer *s, unsigned long data, struct Buffer *err)
	Parse the 'unlists' command - Implements command_t. More...
static enum CommandResult	parse_unmailboxes (struct Buffer *buf, struct Buffer *s, unsigned long data, struct Buffer *err)
	Parse the 'unmailboxes' command - Implements command_t. More...
static enum CommandResult	parse_unmy_hdr (struct Buffer *buf, struct Buffer *s, unsigned long data, struct Buffer *err)
	Parse the 'unmy_hdr' command - Implements command_t. More...
static enum CommandResult	parse_unstailq (struct Buffer *buf, struct Buffer *s, unsigned long data, struct Buffer *err)
	Parse an unlist command - Implements command_t. More...
static enum CommandResult	parse_unsubjectrx_list (struct Buffer *buf, struct Buffer *s, unsigned long data, struct Buffer *err)
	Parse the 'unsubjectrx' command - Implements command_t. More...
static enum CommandResult	parse_unsubscribe (struct Buffer *buf, struct Buffer *s, unsigned long data, struct Buffer *err)
	Parse the 'unsubscribe' command - Implements command_t. More...
static enum CommandResult	parse_unsubscribe_from (struct Buffer *buf, struct Buffer *s, unsigned long data, struct Buffer *err)
	Parse the 'unsubscribe-from' command - Implements command_t. More...
const struct Command *	mutt_command_get (const char *s)
	Get a Command by its name. 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 (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 cs_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 cs_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 cs_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 cs_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 cs_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 cs_validator() More...

Variables
static struct ListHead	MuttrcStack = STAILQ_HEAD_INITIALIZER(MuttrcStack)
static char	UserTyped [1024] = { 0 }
static int	NumMatched = 0
static char	Completed [256] = { 0 }
static const char **	Matches
static int	MatchesListsize = MAX(NUM_VARS, NUM_COMMANDS) + 10
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.

Macro Definition Documentation

MAX_ERRS

#define MAX_ERRS   128

Definition at line 79 of file init.c.

NUM_VARS

#define NUM_VARS   mutt_array_size(MuttVars)

Definition at line 81 of file init.c.

NUM_COMMANDS

#define NUM_COMMANDS   mutt_array_size(Commands)

Definition at line 82 of file init.c.

Enumeration Type Documentation

GroupState

enum GroupState

Type of email address group.

Enumerator
GS_NONE	Group is missing an argument.
GS_RX	Entry is a regular expression.
GS_ADDR	Entry is an address.

Definition at line 102 of file init.c.

{
  GS_NONE, 
  GS_RX,   
  GS_ADDR, 
};

Function Documentation

add_to_stailq()

static void add_to_stailq ( struct ListHead *  head, const char *  str  )

static

Add a string to a list.

Parameters

head	String list
str	String to add

Note

Duplicate or empty strings will not be added

Definition at line 116 of file init.c.

{
  /* don't add a NULL or empty string to the list */
  if (!str || (*str == '\0'))
    return;

  /* check to make sure the item is not already on this list */
  struct ListNode *np = NULL;
  STAILQ_FOREACH(np, head, entries)
  {
    if (mutt_str_strcasecmp(str, np->data) == 0)
    {
      return;
    }
  }
  mutt_list_insert_tail(head, mutt_str_strdup(str));
}

Here is the call graph for this function:

Here is the caller graph for this function:

alternates_clean()

static void alternates_clean ( void  )

static

Clear the recipient valid flag of all emails.

Definition at line 137 of file init.c.

{
  if (!Context)
    return;

  for (int i = 0; i < Context->mailbox->msg_count; i++)
    Context->mailbox->emails[i]->recip_valid = false;
}

Here is the caller graph for this function:

attachments_clean()

static void attachments_clean ( void  )

static

always wise to do what someone else did before

Definition at line 149 of file init.c.

{
  if (!Context)
    return;

  for (int i = 0; i < Context->mailbox->msg_count; i++)
    Context->mailbox->emails[i]->attach_valid = false;
}

Here is the caller graph for this function:

matches_ensure_morespace()

static void matches_ensure_morespace ( int  current )

static

Allocate more space for auto-completion.

Parameters

current

Current allocation

Definition at line 162 of file init.c.

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

  int base_space = MAX(NUM_VARS, NUM_COMMANDS) + 1;
  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 185 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:

clear_subject_mods()

static void clear_subject_mods ( void  )

static

Clear out all modified email subjects.

Definition at line 209 of file init.c.

{
  if (!Context)
    return;

  for (int i = 0; i < Context->mailbox->msg_count; i++)
    FREE(&Context->mailbox->emails[i]->env->disp_subj);
}

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 225 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 282 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));

    if ((rc2 == MUTT_CMD_ERROR) || (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 318 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 359 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 ( void  )

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 391 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(Config, "hostname", C_Hostname, NULL);

  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_attachmatch_new()

static struct AttachMatch* mutt_attachmatch_new ( void  )

static

Create a new AttachMatch.

Return values

ptr	New AttachMatch

Definition at line 464 of file init.c.

{
  return mutt_mem_calloc(1, sizeof(struct AttachMatch));
}

Here is the call graph for this function:

Here is the caller graph for this function:

parse_attach_list()

static enum CommandResult parse_attach_list ( struct Buffer *  buf, struct Buffer *  s, struct ListHead *  head, struct Buffer *  err  )

static

Parse the "attachments" command.

Parameters

buf	Buffer for temporary storage
s	Buffer containing the attachments command
head	List of AttachMatch to add to
err	Buffer for error messages

Return values

CommandResult

Result e.g. MUTT_CMD_SUCCESS

Definition at line 477 of file init.c.

{
  struct AttachMatch *a = NULL;
  char *p = NULL;
  char *tmpminor = NULL;
  size_t len;
  int ret;

  do
  {
    mutt_extract_token(buf, s, MUTT_TOKEN_NO_FLAGS);

    if (!buf->data || (*buf->data == '\0'))
      continue;

    a = mutt_attachmatch_new();

    /* some cheap hacks that I expect to remove */
    if (mutt_str_strcasecmp(buf->data, "any") == 0)
      a->major = mutt_str_strdup("*/.*");
    else if (mutt_str_strcasecmp(buf->data, "none") == 0)
      a->major = mutt_str_strdup("cheap_hack/this_should_never_match");
    else
      a->major = mutt_str_strdup(buf->data);

    p = strchr(a->major, '/');
    if (p)
    {
      *p = '\0';
      p++;
      a->minor = p;
    }
    else
    {
      a->minor = "unknown";
    }

    len = strlen(a->minor);
    tmpminor = mutt_mem_malloc(len + 3);
    strcpy(&tmpminor[1], a->minor);
    tmpminor[0] = '^';
    tmpminor[len + 1] = '$';
    tmpminor[len + 2] = '\0';

    a->major_int = mutt_check_mime_type(a->major);
    ret = REG_COMP(&a->minor_regex, tmpminor, REG_ICASE);

    FREE(&tmpminor);

    if (ret != 0)
    {
      regerror(ret, &a->minor_regex, err->data, err->dsize);
      FREE(&a->major);
      FREE(&a);
      return MUTT_CMD_ERROR;
    }

    mutt_debug(LL_DEBUG3, "added %s/%s [%d]\n", a->major, a->minor, a->major_int);

    mutt_list_insert_tail(head, (char *) a);
  } while (MoreArgs(s));

  attachments_clean();
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

parse_grouplist()

static int parse_grouplist ( struct GroupList *  gl, struct Buffer *  buf, struct Buffer *  s, unsigned long  data, struct Buffer *  err  )

static

Parse a group context.

Parameters

gl	GroupList to add to
buf	Temporary Buffer space
s	Buffer containing string to be parsed
data	Flags associated with the command
err	Buffer for error messages

Return values

0	Success
-1	Error

Definition at line 554 of file init.c.

{
  while (mutt_str_strcasecmp(buf->data, "-group") == 0)
  {
    if (!MoreArgs(s))
    {
      mutt_buffer_strcpy(err, _("-group: no group name"));
      return -1;
    }

    mutt_extract_token(buf, s, MUTT_TOKEN_NO_FLAGS);

    mutt_grouplist_add(gl, mutt_pattern_group(buf->data));

    if (!MoreArgs(s))
    {
      mutt_buffer_strcpy(err, _("out of arguments"));
      return -1;
    }

    mutt_extract_token(buf, s, MUTT_TOKEN_NO_FLAGS);
  }

  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

parse_replace_list()

static enum CommandResult parse_replace_list ( struct Buffer *  buf, struct Buffer *  s, unsigned long  data, struct Buffer *  err  )

static

Parse a string replacement rule - Implements command_t.

Definition at line 584 of file init.c.

{
  struct ReplaceList *list = (struct ReplaceList *) data;
  struct Buffer templ = mutt_buffer_make(0);

  /* First token is a regex. */
  if (!MoreArgs(s))
  {
    mutt_buffer_printf(err, _("%s: too few arguments"), "subjectrx");
    return MUTT_CMD_WARNING;
  }
  mutt_extract_token(buf, s, MUTT_TOKEN_NO_FLAGS);

  /* Second token is a replacement template */
  if (!MoreArgs(s))
  {
    mutt_buffer_printf(err, _("%s: too few arguments"), "subjectrx");
    return MUTT_CMD_WARNING;
  }
  mutt_extract_token(&templ, s, MUTT_TOKEN_NO_FLAGS);

  if (mutt_replacelist_add(list, buf->data, templ.data, err) != 0)
  {
    FREE(&templ.data);
    return MUTT_CMD_ERROR;
  }
  FREE(&templ.data);

  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

parse_unattach_list()

static enum CommandResult parse_unattach_list ( struct Buffer *  buf, struct Buffer *  s, struct ListHead *  head, struct Buffer *  err  )

static

Parse the "unattachments" command.

Parameters

buf	Buffer for temporary storage
s	Buffer containing the unattachments command
head	List of AttachMatch to remove from
err	Buffer for error messages

Return values

MUTT_CMD_SUCCESS

Always

Definition at line 624 of file init.c.

{
  struct AttachMatch *a = NULL;
  char *tmp = NULL;
  char *minor = NULL;

  do
  {
    mutt_extract_token(buf, s, MUTT_TOKEN_NO_FLAGS);
    FREE(&tmp);

    if (mutt_str_strcasecmp(buf->data, "any") == 0)
      tmp = mutt_str_strdup("*/.*");
    else if (mutt_str_strcasecmp(buf->data, "none") == 0)
      tmp = mutt_str_strdup("cheap_hack/this_should_never_match");
    else
      tmp = mutt_str_strdup(buf->data);

    minor = strchr(tmp, '/');
    if (minor)
    {
      *minor = '\0';
      minor++;
    }
    else
    {
      minor = "unknown";
    }
    const enum ContentType major = mutt_check_mime_type(tmp);

    struct ListNode *np = NULL, *tmp2 = NULL;
    STAILQ_FOREACH_SAFE(np, head, entries, tmp2)
    {
      a = (struct AttachMatch *) np->data;
      mutt_debug(LL_DEBUG3, "check %s/%s [%d] : %s/%s [%d]\n", a->major,
                 a->minor, a->major_int, tmp, minor, major);
      if ((a->major_int == major) && (mutt_str_strcasecmp(minor, a->minor) == 0))
      {
        mutt_debug(LL_DEBUG3, "removed %s/%s [%d]\n", a->major, a->minor, a->major_int);
        regfree(&a->minor_regex);
        FREE(&a->major);
        STAILQ_REMOVE(head, np, ListNode, entries);
        FREE(&np->data);
        FREE(&np);
      }
    }

  } while (MoreArgs(s));

  FREE(&tmp);
  attachments_clean();
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

parse_unreplace_list()

static enum CommandResult parse_unreplace_list ( struct Buffer *  buf, struct Buffer *  s, unsigned long  data, struct Buffer *  err  )

static

Remove a string replacement rule - Implements command_t.

Definition at line 682 of file init.c.

{
  struct ReplaceList *list = (struct ReplaceList *) data;

  /* First token is a regex. */
  if (!MoreArgs(s))
  {
    mutt_buffer_printf(err, _("%s: too few arguments"), "unsubjectrx");
    return MUTT_CMD_WARNING;
  }

  mutt_extract_token(buf, s, MUTT_TOKEN_NO_FLAGS);

  /* "*" is a special case. */
  if (mutt_str_strcmp(buf->data, "*") == 0)
  {
    mutt_replacelist_free(list);
    return MUTT_CMD_SUCCESS;
  }

  mutt_replacelist_remove(list, buf->data);
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

print_attach_list()

static int print_attach_list ( struct ListHead *  h, const char  op, const char *  name  )

static

Print a list of attachments.

Parameters

h	List of attachments
op	Operation, e.g. '+', '-'
name	Attached/Inline, 'A', 'I'

Return values

0

Always

Definition at line 714 of file init.c.

{
  struct ListNode *np = NULL;
  STAILQ_FOREACH(np, h, entries)
  {
    printf("attachments %c%s %s/%s\n", op, name,
           ((struct AttachMatch *) np->data)->major,
           ((struct AttachMatch *) np->data)->minor);
  }

  return 0;
}

Here is the caller graph for this function:

remove_from_stailq()

static void remove_from_stailq ( struct ListHead *  head, const char *  str  )

static

Remove an item, matching a string, from a List.

Parameters

head	Head of the List
str	String to match

Note

The string comparison is case-insensitive

Definition at line 734 of file init.c.

{
  if (mutt_str_strcmp("*", str) == 0)
    mutt_list_free(head); /* "unCMD *" means delete all current entries */
  else
  {
    struct ListNode *np = NULL, *tmp = NULL;
    STAILQ_FOREACH_SAFE(np, head, entries, tmp)
    {
      if (mutt_str_strcasecmp(str, np->data) == 0)
      {
        STAILQ_REMOVE(head, np, ListNode, entries);
        FREE(&np->data);
        FREE(&np);
        break;
      }
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

source_rc()

static int source_rc ( const char *  rcfile_path, struct Buffer *  err  )

static

Read an initialization file.

Parameters

rcfile_path	Path to initialization file
err	Buffer for error messages

Return values

<0	if neomutt should pause to let the user know

Definition at line 760 of file init.c.

{
  int line = 0, rc = 0, warnings = 0;
  enum CommandResult line_rc;
  struct Buffer token;
  char *linebuf = NULL;
  char *currentline = NULL;
  char rcfile[PATH_MAX];
  size_t buflen;

  pid_t pid;

  mutt_str_strfcpy(rcfile, rcfile_path, sizeof(rcfile));

  size_t rcfilelen = mutt_str_strlen(rcfile);
  if (rcfilelen == 0)
    return -1;

  bool ispipe = rcfile[rcfilelen - 1] == '|';

  if (!ispipe)
  {
    struct ListNode *np = STAILQ_FIRST(&MuttrcStack);
    if (!mutt_path_to_absolute(rcfile, np ? NONULL(np->data) : ""))
    {
      mutt_error(_("Error: Can't build path of '%s'"), rcfile_path);
      return -1;
    }

    STAILQ_FOREACH(np, &MuttrcStack, entries)
    {
      if (mutt_str_strcmp(np->data, rcfile) == 0)
      {
        break;
      }
    }
    if (np)
    {
      mutt_error(_("Error: Cyclic sourcing of configuration file '%s'"), rcfile);
      return -1;
    }

    mutt_list_insert_head(&MuttrcStack, mutt_str_strdup(rcfile));
  }

  mutt_debug(LL_DEBUG2, "Reading configuration file '%s'\n", rcfile);

  FILE *fp = mutt_open_read(rcfile, &pid);
  if (!fp)
  {
    mutt_buffer_printf(err, "%s: %s", rcfile, strerror(errno));
    return -1;
  }

  mutt_buffer_init(&token);
  while ((linebuf = mutt_file_read_line(linebuf, &buflen, fp, &line, MUTT_CONT)))
  {
    const bool conv = C_ConfigCharset && C_Charset;
    if (conv)
    {
      currentline = mutt_str_strdup(linebuf);
      if (!currentline)
        continue;
      mutt_ch_convert_string(&currentline, C_ConfigCharset, C_Charset, 0);
    }
    else
      currentline = linebuf;
    mutt_buffer_reset(err);
    line_rc = mutt_parse_rc_line(currentline, &token, err);
    if (line_rc == MUTT_CMD_ERROR)
    {
      mutt_error(_("Error in %s, line %d: %s"), rcfile, line, err->data);
      if (--rc < -MAX_ERRS)
      {
        if (conv)
          FREE(&currentline);
        break;
      }
    }
    else if (line_rc == MUTT_CMD_WARNING)
    {
      /* Warning */
      mutt_warning(_("Warning in %s, line %d: %s"), rcfile, line, err->data);
      warnings++;
    }
    else if (line_rc == MUTT_CMD_FINISH)
    {
      break; /* Found "finish" command */
    }
    else
    {
      if (rc < 0)
        rc = -1;
    }
    if (conv)
      FREE(&currentline);
  }
  FREE(&token.data);
  FREE(&linebuf);
  mutt_file_fclose(&fp);
  if (pid != -1)
    mutt_wait_filter(pid);
  if (rc)
  {
    /* the neomuttrc source keyword */
    mutt_buffer_reset(err);
    mutt_buffer_printf(err, (rc >= -MAX_ERRS) ? _("source: errors in %s") : _("source: reading aborted due to too many errors in %s"),
                       rcfile);
    rc = -1;
  }
  else
  {
    /* Don't alias errors with warnings */
    if (warnings > 0)
    {
      mutt_buffer_printf(err, ngettext("source: %d warning in %s", "source: %d warnings in %s", warnings),
                         warnings, rcfile);
      rc = -2;
    }
  }

  if (!ispipe && !STAILQ_EMPTY(&MuttrcStack))
  {
    struct ListNode *np = STAILQ_FIRST(&MuttrcStack);
    STAILQ_REMOVE_HEAD(&MuttrcStack, entries);
    FREE(&np->data);
    FREE(&np);
  }

  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

parse_alias()

static enum CommandResult parse_alias ( struct Buffer *  buf, struct Buffer *  s, unsigned long  data, struct Buffer *  err  )

static

Parse the 'alias' command - Implements command_t.

Definition at line 895 of file init.c.

{
  struct Alias *tmp = NULL;
  char *estr = NULL;
  struct GroupList gl = STAILQ_HEAD_INITIALIZER(gl);

  if (!MoreArgs(s))
  {
    mutt_buffer_strcpy(err, _("alias: no address"));
    return MUTT_CMD_WARNING;
  }

  mutt_extract_token(buf, s, MUTT_TOKEN_NO_FLAGS);

  if (parse_grouplist(&gl, buf, s, data, err) == -1)
    return MUTT_CMD_ERROR;

  /* check to see if an alias with this name already exists */
  TAILQ_FOREACH(tmp, &Aliases, entries)
  {
    if (mutt_str_strcasecmp(tmp->name, buf->data) == 0)
      break;
  }

  if (tmp)
  {
    mutt_alias_delete_reverse(tmp);
    /* override the previous value */
    mutt_addrlist_clear(&tmp->addr);
    if (CurrentMenu == MENU_ALIAS)
      mutt_menu_set_current_redraw_full();
  }
  else
  {
    /* create a new alias */
    tmp = mutt_alias_new();
    tmp->name = mutt_str_strdup(buf->data);
    TAILQ_INSERT_TAIL(&Aliases, tmp, entries);
    /* give the main addressbook code a chance */
    if (CurrentMenu == MENU_ALIAS)
      OptMenuCaller = true;
  }

  mutt_extract_token(buf, s, MUTT_TOKEN_QUOTE | MUTT_TOKEN_SPACE | MUTT_TOKEN_SEMICOLON);
  mutt_debug(LL_DEBUG5, "Second token is '%s'\n", buf->data);

  mutt_addrlist_parse2(&tmp->addr, buf->data);

  if (mutt_addrlist_to_intl(&tmp->addr, &estr))
  {
    mutt_buffer_printf(err, _("Warning: Bad IDN '%s' in alias '%s'"), estr, tmp->name);
    FREE(&estr);
    goto bail;
  }

  mutt_grouplist_add_addrlist(&gl, &tmp->addr);
  mutt_alias_add_reverse(tmp);

  if (C_DebugLevel > LL_DEBUG4)
  {
    /* A group is terminated with an empty address, so check a->mailbox */
    struct Address *a = NULL;
    TAILQ_FOREACH(a, &tmp->addr, entries)
    {
      if (!a->mailbox)
        break;

      if (a->group)
        mutt_debug(LL_DEBUG5, "  Group %s\n", a->mailbox);
      else
        mutt_debug(LL_DEBUG5, "  %s\n", a->mailbox);
    }
  }
  mutt_grouplist_destroy(&gl);
  return MUTT_CMD_SUCCESS;

bail:
  mutt_grouplist_destroy(&gl);
  return MUTT_CMD_ERROR;
}

Here is the call graph for this function:

parse_alternates()

static enum CommandResult parse_alternates ( struct Buffer *  buf, struct Buffer *  s, unsigned long  data, struct Buffer *  err  )

static

Parse the 'alternates' command - Implements command_t.

Definition at line 980 of file init.c.

{
  struct GroupList gl = STAILQ_HEAD_INITIALIZER(gl);

  alternates_clean();

  do
  {
    mutt_extract_token(buf, s, MUTT_TOKEN_NO_FLAGS);

    if (parse_grouplist(&gl, buf, s, data, err) == -1)
      goto bail;

    mutt_regexlist_remove(&UnAlternates, buf->data);

    if (mutt_regexlist_add(&Alternates, buf->data, REG_ICASE, err) != 0)
      goto bail;

    if (mutt_grouplist_add_regex(&gl, buf->data, REG_ICASE, err) != 0)
      goto bail;
  } while (MoreArgs(s));

  mutt_grouplist_destroy(&gl);
  return MUTT_CMD_SUCCESS;

bail:
  mutt_grouplist_destroy(&gl);
  return MUTT_CMD_ERROR;
}

Here is the call graph for this function:

parse_attachments()

static enum CommandResult parse_attachments ( struct Buffer *  buf, struct Buffer *  s, unsigned long  data, struct Buffer *  err  )

static

Parse the 'attachments' command - Implements command_t.

Definition at line 1014 of file init.c.

{
  char op;
  char *category = NULL;
  struct ListHead *head = NULL;

  mutt_extract_token(buf, s, MUTT_TOKEN_NO_FLAGS);
  if (!buf->data || (*buf->data == '\0'))
  {
    mutt_buffer_strcpy(err, _("attachments: no disposition"));
    return MUTT_CMD_WARNING;
  }

  category = buf->data;
  op = *category++;

  if (op == '?')
  {
    mutt_endwin();
    fflush(stdout);
    printf("\n%s\n\n", _("Current attachments settings:"));
    print_attach_list(&AttachAllow, '+', "A");
    print_attach_list(&AttachExclude, '-', "A");
    print_attach_list(&InlineAllow, '+', "I");
    print_attach_list(&InlineExclude, '-', "I");
    mutt_any_key_to_continue(NULL);
    return MUTT_CMD_SUCCESS;
  }

  if ((op != '+') && (op != '-'))
  {
    op = '+';
    category--;
  }
  if (mutt_str_startswith("attachment", category, CASE_IGNORE))
  {
    if (op == '+')
      head = &AttachAllow;
    else
      head = &AttachExclude;
  }
  else if (mutt_str_startswith("inline", category, CASE_IGNORE))
  {
    if (op == '+')
      head = &InlineAllow;
    else
      head = &InlineExclude;
  }
  else
  {
    mutt_buffer_strcpy(err, _("attachments: invalid disposition"));
    return MUTT_CMD_ERROR;
  }

  return parse_attach_list(buf, s, head, err);
}

Here is the call graph for this function:

parse_echo()

static enum CommandResult parse_echo ( struct Buffer *  buf, struct Buffer *  s, unsigned long  data, struct Buffer *  err  )

static

Parse the 'echo' command - Implements command_t.

Definition at line 1075 of file init.c.

{
  if (!MoreArgs(s))
  {
    mutt_buffer_printf(err, _("%s: too few arguments"), "echo");
    return MUTT_CMD_WARNING;
  }
  mutt_extract_token(buf, s, MUTT_TOKEN_NO_FLAGS);
  OptForceRefresh = true;
  mutt_message("%s", buf->data);
  OptForceRefresh = false;
  mutt_sleep(0);

  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

parse_finish()

static enum CommandResult parse_finish ( struct Buffer *  buf, struct Buffer *  s, unsigned long  data, struct Buffer *  err  )

static

Parse the 'finish' command - Implements command_t.

Return values

MUTT_CMD_FINISH	Stop processing the current file
MUTT_CMD_WARNING	Failed

If the 'finish' command is found, we should stop reading the current file.

Definition at line 1099 of file init.c.

{
  if (MoreArgs(s))
  {
    mutt_buffer_printf(err, _("%s: too many arguments"), "finish");
    return MUTT_CMD_WARNING;
  }

  return MUTT_CMD_FINISH;
}

Here is the call graph for this function:

parse_group()

static enum CommandResult parse_group ( struct Buffer *  buf, struct Buffer *  s, unsigned long  data, struct Buffer *  err  )

static

Parse the 'group' and 'ungroup' commands - Implements command_t.

Definition at line 1114 of file init.c.

{
  struct GroupList gl = STAILQ_HEAD_INITIALIZER(gl);
  enum GroupState state = GS_NONE;

  do
  {
    mutt_extract_token(buf, s, MUTT_TOKEN_NO_FLAGS);
    if (parse_grouplist(&gl, buf, s, data, err) == -1)
      goto bail;

    if ((data == MUTT_UNGROUP) && (mutt_str_strcasecmp(buf->data, "*") == 0))
    {
      mutt_grouplist_clear(&gl);
      goto out;
    }

    if (mutt_str_strcasecmp(buf->data, "-rx") == 0)
      state = GS_RX;
    else if (mutt_str_strcasecmp(buf->data, "-addr") == 0)
      state = GS_ADDR;
    else
    {
      switch (state)
      {
        case GS_NONE:
          mutt_buffer_printf(err, _("%sgroup: missing -rx or -addr"),
                             (data == MUTT_UNGROUP) ? "un" : "");
          goto warn;

        case GS_RX:
          if ((data == MUTT_GROUP) &&
              (mutt_grouplist_add_regex(&gl, buf->data, REG_ICASE, err) != 0))
          {
            goto bail;
          }
          else if ((data == MUTT_UNGROUP) &&
                   (mutt_grouplist_remove_regex(&gl, buf->data) < 0))
          {
            goto bail;
          }
          break;

        case GS_ADDR:
        {
          char *estr = NULL;
          struct AddressList al = TAILQ_HEAD_INITIALIZER(al);
          mutt_addrlist_parse2(&al, buf->data);
          if (TAILQ_EMPTY(&al))
            goto bail;
          if (mutt_addrlist_to_intl(&al, &estr))
          {
            mutt_buffer_printf(err, _("%sgroup: warning: bad IDN '%s'"),
                               (data == 1) ? "un" : "", estr);
            mutt_addrlist_clear(&al);
            FREE(&estr);
            goto bail;
          }
          if (data == MUTT_GROUP)
            mutt_grouplist_add_addrlist(&gl, &al);
          else if (data == MUTT_UNGROUP)
            mutt_grouplist_remove_addrlist(&gl, &al);
          mutt_addrlist_clear(&al);
          break;
        }
      }
    }
  } while (MoreArgs(s));

out:
  mutt_grouplist_destroy(&gl);
  return MUTT_CMD_SUCCESS;

bail:
  mutt_grouplist_destroy(&gl);
  return MUTT_CMD_ERROR;

warn:
  mutt_grouplist_destroy(&gl);
  return MUTT_CMD_WARNING;
}

Here is the call graph for this function:

is_function()

static bool is_function ( const char *  name )

static

Is the argument a neomutt function?

Parameters

name	Command name to be searched for

Return values

true	Function found
false	Function not found

Definition at line 1203 of file init.c.

{
  for (enum MenuType i = 0; i < MENU_MAX; i++)
  {
    const struct Binding *b = km_get_table(Menus[i].value);
    if (!b)
      continue;

    for (int j = 0; b[j].name; j++)
      if (mutt_str_strcmp(name, b[j].name) == 0)
        return true;
  }
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

parse_ifdef()

static enum CommandResult parse_ifdef ( struct Buffer *  buf, struct Buffer *  s, unsigned long  data, struct Buffer *  err  )

static

Parse the 'ifdef' and 'ifndef' commands - Implements command_t.

The 'ifdef' command allows conditional elements in the config file. If a given variable, function, command or compile-time symbol exists, then read the rest of the line of config commands. e.g. ifdef sidebar source ~/.neomutt/sidebar.rc

If (data == 1) then it means use the 'ifndef' (if-not-defined) command. e.g. ifndef imap finish

Definition at line 1231 of file init.c.

{
  struct Buffer token = mutt_buffer_make(0);

  mutt_extract_token(buf, s, MUTT_TOKEN_NO_FLAGS);

  // is the item defined as:
  bool res = cs_get_elem(Config, buf->data) // a variable?
             || feature_enabled(buf->data)  // a compiled-in feature?
             || is_function(buf->data)      // a function?
             || mutt_command_get(buf->data) // a command?
             || myvar_get(buf->data)        // a my_ variable?
             || mutt_str_getenv(buf->data); // an environment variable?

  if (!MoreArgs(s))
  {
    mutt_buffer_printf(err, _("%s: too few arguments"), (data ? "ifndef" : "ifdef"));
    return MUTT_CMD_WARNING;
  }
  mutt_extract_token(buf, s, MUTT_TOKEN_SPACE);

  /* ifdef KNOWN_SYMBOL or ifndef UNKNOWN_SYMBOL */
  if ((res && (data == 0)) || (!res && (data == 1)))
  {
    enum CommandResult rc = mutt_parse_rc_line(buf->data, &token, err);
    if (rc == MUTT_CMD_ERROR)
    {
      mutt_error(_("Error: %s"), err->data);
      FREE(&token.data);
      return MUTT_CMD_ERROR;
    }
    FREE(&token.data);
    return rc;
  }
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

parse_ignore()

static enum CommandResult parse_ignore ( struct Buffer *  buf, struct Buffer *  s, unsigned long  data, struct Buffer *  err  )

static

Parse the 'ignore' command - Implements command_t.

Definition at line 1272 of file init.c.

{
  do
  {
    mutt_extract_token(buf, s, MUTT_TOKEN_NO_FLAGS);
    remove_from_stailq(&UnIgnore, buf->data);
    add_to_stailq(&Ignore, buf->data);
  } while (MoreArgs(s));

  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

parse_lists()

static enum CommandResult parse_lists ( struct Buffer *  buf, struct Buffer *  s, unsigned long  data, struct Buffer *  err  )

static

Parse the 'lists' command - Implements command_t.

Definition at line 1288 of file init.c.

{
  struct GroupList gl = STAILQ_HEAD_INITIALIZER(gl);

  do
  {
    mutt_extract_token(buf, s, MUTT_TOKEN_NO_FLAGS);

    if (parse_grouplist(&gl, buf, s, data, err) == -1)
      goto bail;

    mutt_regexlist_remove(&UnMailLists, buf->data);

    if (mutt_regexlist_add(&MailLists, buf->data, REG_ICASE, err) != 0)
      goto bail;

    if (mutt_grouplist_add_regex(&gl, buf->data, REG_ICASE, err) != 0)
      goto bail;
  } while (MoreArgs(s));

  mutt_grouplist_destroy(&gl);
  return MUTT_CMD_SUCCESS;

bail:
  mutt_grouplist_destroy(&gl);
  return MUTT_CMD_ERROR;
}

Here is the call graph for this function:

parse_mailboxes()

static enum CommandResult parse_mailboxes ( struct Buffer *  buf, struct Buffer *  s, unsigned long  data, struct Buffer *  err  )

static

Parse the 'mailboxes' command - Implements command_t.

This is also used by 'virtual-mailboxes'.

Definition at line 1322 of file init.c.

{
  while (MoreArgs(s))
  {
    struct Mailbox *m = mailbox_new();

    if (data & MUTT_NAMED)
    {
      mutt_extract_token(buf, s, MUTT_TOKEN_NO_FLAGS);
      if (buf->data && (*buf->data != '\0'))
      {
        m->name = mutt_str_strdup(buf->data);
      }
      else
      {
        mailbox_free(&m);
        continue;
      }
    }

    mutt_extract_token(buf, s, MUTT_TOKEN_NO_FLAGS);
    if (mutt_buffer_is_empty(buf))
    {
      /* Skip empty tokens. */
      mailbox_free(&m);
      continue;
    }

    mutt_buffer_strcpy(&m->pathbuf, buf->data);
    /* int rc = */ mx_path_canon2(m, C_Folder);

    if (m->magic <= MUTT_UNKNOWN)
    {
      mutt_error("Unknown Mailbox: %s", m->realpath);
      mailbox_free(&m);
      return MUTT_CMD_ERROR;
    }

    bool new_account = false;
    struct Account *a = mx_ac_find(m);
    if (!a)
    {
      a = account_new(NULL, NeoMutt->sub);
      a->magic = m->magic;
      new_account = true;
    }

    if (!new_account)
    {
      struct Mailbox *m_old = mx_mbox_find(a, m->realpath);
      if (m_old)
      {
        if (m_old->flags == MB_HIDDEN)
        {
          m_old->flags = MB_NORMAL;
          mutt_sb_notify_mailbox(m_old, true);
        }
        mailbox_free(&m);
        continue;
      }
    }

    if (mx_ac_add(a, m) < 0)
    {
      //error
      mailbox_free(&m);
      if (new_account)
      {
        cs_subset_free(&a->sub);
        FREE(&a->name);
        notify_free(&a->notify);
        FREE(&a);
      }
      continue;
    }
    if (new_account)
    {
      neomutt_account_add(NeoMutt, a);
    }

#ifdef USE_SIDEBAR
    mutt_sb_notify_mailbox(m, true);
#endif
#ifdef USE_INOTIFY
    mutt_monitor_add(m);
#endif
  }
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

parse_my_hdr()

static enum CommandResult parse_my_hdr ( struct Buffer *  buf, struct Buffer *  s, unsigned long  data, struct Buffer *  err  )

static

Parse the 'my_hdr' command - Implements command_t.

Definition at line 1416 of file init.c.

{
  struct ListNode *n = NULL;
  size_t keylen;

  mutt_extract_token(buf, s, MUTT_TOKEN_SPACE | MUTT_TOKEN_QUOTE);
  char *p = strpbrk(buf->data, ": \t");
  if (!p || (*p != ':'))
  {
    mutt_buffer_strcpy(err, _("invalid header field"));
    return MUTT_CMD_WARNING;
  }
  keylen = p - buf->data + 1;

  STAILQ_FOREACH(n, &UserHeader, entries)
  {
    /* see if there is already a field by this name */
    if (mutt_str_strncasecmp(buf->data, n->data, keylen) == 0)
    {
      break;
    }
  }

  if (!n)
  {
    /* not found, allocate memory for a new node and add it to the list */
    n = mutt_list_insert_tail(&UserHeader, NULL);
  }
  else
  {
    /* found, free the existing data */
    FREE(&n->data);
  }

  n->data = buf->data;
  mutt_buffer_init(buf);

  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

parse_path_list()

static enum CommandResult parse_path_list ( struct Buffer *  buf, struct Buffer *  s, unsigned long  data, struct Buffer *  err  )

static

Parse the 'sidebar_whitelist' command - Implements command_t.

Definition at line 1461 of file init.c.

{
  struct Buffer *path = mutt_buffer_pool_get();

  do
  {
    mutt_extract_token(path, s, MUTT_TOKEN_NO_FLAGS);
    mutt_buffer_expand_path(path);
    add_to_stailq((struct ListHead *) data, mutt_b2s(path));
  } while (MoreArgs(s));
  mutt_buffer_pool_release(&path);

  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

parse_path_unlist()

static enum CommandResult parse_path_unlist ( struct Buffer *  buf, struct Buffer *  s, unsigned long  data, struct Buffer *  err  )

static

Parse the 'unsidebar_whitelist' command - Implements command_t.

Definition at line 1482 of file init.c.

{
  struct Buffer *path = mutt_buffer_pool_get();

  do
  {
    mutt_extract_token(path, s, MUTT_TOKEN_NO_FLAGS);
    /* Check for deletion of entire list */
    if (mutt_str_strcmp(mutt_b2s(path), "*") == 0)
    {
      mutt_list_free((struct ListHead *) data);
      break;
    }
    mutt_buffer_expand_path(path);
    remove_from_stailq((struct ListHead *) data, mutt_b2s(path));
  } while (MoreArgs(s));
  mutt_buffer_pool_release(&path);

  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

parse_set()

static enum CommandResult parse_set ( struct Buffer *  buf, struct Buffer *  s, unsigned long  data, struct Buffer *  err  )

static

Parse the 'set' family of commands - Implements command_t.

This is used by 'reset', 'set', 'toggle' and 'unset'.

Definition at line 1510 of file init.c.

{
  /* The order must match `enum MuttSetCommand` */
  static const char *set_commands[] = { "set", "toggle", "unset", "reset" };

  int rc = 0;

  while (MoreArgs(s))
  {
    bool prefix = false;
    bool query = false;
    bool inv = (data == MUTT_SET_INV);
    bool reset = (data == MUTT_SET_RESET);
    bool unset = (data == MUTT_SET_UNSET);

    if (*s->dptr == '?')
    {
      prefix = true;
      query = true;
      s->dptr++;
    }
    else if (mutt_str_startswith(s->dptr, "no", CASE_MATCH))
    {
      prefix = true;
      unset = !unset;
      s->dptr += 2;
    }
    else if (mutt_str_startswith(s->dptr, "inv", CASE_MATCH))
    {
      prefix = true;
      inv = !inv;
      s->dptr += 3;
    }
    else if (*s->dptr == '&')
    {
      prefix = true;
      reset = true;
      s->dptr++;
    }

    if (prefix && (data != MUTT_SET_SET))
    {
      mutt_buffer_printf(err, "ERR22 can't use 'inv', 'no', '&' or '?' with the '%s' command",
                         set_commands[data]);
      return MUTT_CMD_WARNING;
    }

    /* get the variable name */
    mutt_extract_token(buf, s, MUTT_TOKEN_EQUAL | MUTT_TOKEN_QUESTION);

    bool bq = false;
    bool equals = false;

    struct HashElem *he = NULL;
    bool my = mutt_str_startswith(buf->data, "my_", CASE_MATCH);
    if (!my)
    {
      he = cs_get_elem(Config, buf->data);
      if (!he)
      {
        if (reset && (mutt_str_strcmp(buf->data, "all") == 0))
        {
          struct HashElem **list = get_elem_list(Config);
          if (!list)
            return MUTT_CMD_ERROR;

          for (size_t i = 0; list[i]; i++)
            cs_he_reset(Config, list[i], NULL);

          FREE(&list);
          break;
        }
        else
        {
          mutt_buffer_printf(err, "ERR01 unknown variable: %s", buf->data);
          return MUTT_CMD_ERROR;
        }
      }

      bq = ((DTYPE(he->type) == DT_BOOL) || (DTYPE(he->type) == DT_QUAD));
    }

    if (*s->dptr == '?')
    {
      if (prefix)
      {
        mutt_buffer_printf(err,
                           "ERR02 can't use a prefix when querying a variable");
        return MUTT_CMD_WARNING;
      }

      if (reset || unset || inv)
      {
        mutt_buffer_printf(err, "ERR03 can't query a variable with the '%s' command",
                           set_commands[data]);
        return MUTT_CMD_WARNING;
      }

      query = true;
      s->dptr++;
    }
    else if (*s->dptr == '=')
    {
      if (prefix)
      {
        mutt_buffer_printf(err,
                           "ERR04 can't use prefix when setting a variable");
        return MUTT_CMD_WARNING;
      }

      if (reset || unset || inv)
      {
        mutt_buffer_printf(err, "ERR05 can't set a variable with the '%s' command",
                           set_commands[data]);
        return MUTT_CMD_WARNING;
      }

      equals = true;
      s->dptr++;
    }

    if (!bq && (inv || (unset && prefix)))
    {
      if (data == MUTT_SET_SET)
      {
        mutt_buffer_printf(err, "ERR06 prefixes 'no' and 'inv' may only be "
                                "used with bool/quad variables");
      }
      else
      {
        mutt_buffer_printf(err, "ERR07 command '%s' can only be used with bool/quad variables",
                           set_commands[data]);
      }
      return MUTT_CMD_WARNING;
    }

    if (reset)
    {
      // mutt_buffer_printf(err, "ACT24 reset variable %s", buf->data);
      if (he)
      {
        rc = cs_he_reset(Config, he, err);
        if (CSR_RESULT(rc) != CSR_SUCCESS)
          return MUTT_CMD_ERROR;
      }
      else
      {
        myvar_del(buf->data);
      }
      continue;
    }

    if ((data == MUTT_SET_SET) && !inv && !unset)
    {
      if (query)
      {
        // mutt_buffer_printf(err, "ACT08 query variable %s", buf->data);
        if (he)
        {
          mutt_buffer_addstr(err, buf->data);
          mutt_buffer_addch(err, '=');
          mutt_buffer_reset(buf);
          rc = cs_he_string_get(Config, he, buf);
          if (CSR_RESULT(rc) != CSR_SUCCESS)
          {
            mutt_buffer_addstr(err, buf->data);
            return MUTT_CMD_ERROR;
          }
          pretty_var(buf->data, err);
        }
        else
        {
          const char *val = myvar_get(buf->data);
          if (val)
          {
            mutt_buffer_addstr(err, buf->data);
            mutt_buffer_addch(err, '=');
            pretty_var(val, err);
          }
          else
          {
            mutt_buffer_printf(err, _("%s: unknown variable"), buf->data);
            return MUTT_CMD_ERROR;
          }
        }
        break;
      }
      else if (equals)
      {
        // mutt_buffer_printf(err, "ACT11 set variable %s to ", buf->data);
        const char *name = NULL;
        if (my)
        {
          name = mutt_str_strdup(buf->data);
        }
        mutt_extract_token(buf, s, MUTT_TOKEN_BACKTICK_VARS);
        if (my)
        {
          myvar_set(name, buf->data);
          FREE(&name);
        }
        else
        {
          if (IS_PATH(he))
          {
            mutt_buffer_expand_path(buf);
            struct Buffer scratch = mutt_buffer_make(1024);
            mutt_buffer_copy(&scratch, buf);
            size_t scratchlen = mutt_buffer_len(&scratch);
            if (!(he->type & DT_MAILBOX) && (scratchlen != 0))
            {
              if ((mutt_b2s(&scratch)[scratchlen - 1] != '|') && /* not a command */
                  (url_check_scheme(mutt_b2s(&scratch)) == U_UNKNOWN)) /* probably a local file */
              {
                struct ListNode *np = STAILQ_FIRST(&MuttrcStack);
                if (mutt_path_to_absolute(scratch.data, np ? NONULL(np->data) : "./"))
                {
                  mutt_buffer_reset(buf);
                  mutt_buffer_addstr(buf, mutt_b2s(&scratch));
                }
                else
                {
                  mutt_error(_("Error: Can't build path of '%s'"), mutt_b2s(&scratch));
                }
              }
            }
            mutt_buffer_dealloc(&scratch);
          }
          else if (IS_COMMAND(he))
          {
            struct Buffer scratch = mutt_buffer_make(1024);
            mutt_buffer_copy(&scratch, buf);

            if (mutt_str_strcmp(buf->data, "builtin") != 0)
            {
              mutt_buffer_expand_path(&scratch);
            }
            mutt_buffer_reset(buf);
            mutt_buffer_addstr(buf, mutt_b2s(&scratch));
            mutt_buffer_dealloc(&scratch);
          }

          rc = cs_he_string_set(Config, he, buf->data, err);
          if (CSR_RESULT(rc) != CSR_SUCCESS)
            return MUTT_CMD_ERROR;
        }
        continue;
      }
      else
      {
        if (bq)
        {
          // mutt_buffer_printf(err, "ACT23 set variable %s to 'yes'", buf->data);
          rc = cs_he_native_set(Config, he, true, err);
          if (CSR_RESULT(rc) != CSR_SUCCESS)
            return MUTT_CMD_ERROR;
          continue;
        }
        else
        {
          // mutt_buffer_printf(err, "ACT10 query variable %s", buf->data);
          if (he)
          {
            mutt_buffer_addstr(err, buf->data);
            mutt_buffer_addch(err, '=');
            mutt_buffer_reset(buf);
            rc = cs_he_string_get(Config, he, buf);
            if (CSR_RESULT(rc) != CSR_SUCCESS)
            {
              mutt_buffer_addstr(err, buf->data);
              return MUTT_CMD_ERROR;
            }
            pretty_var(buf->data, err);
          }
          else
          {
            const char *val = myvar_get(buf->data);
            if (val)
            {
              mutt_buffer_addstr(err, buf->data);
              mutt_buffer_addch(err, '=');
              pretty_var(val, err);
            }
            else
            {
              mutt_buffer_printf(err, _("%s: unknown variable"), buf->data);
              return MUTT_CMD_ERROR;
            }
          }
          break;
        }
      }
    }

    if (my)
    {
      myvar_del(buf->data);
    }
    else if (bq)
    {
      if (inv)
      {
        // mutt_buffer_printf(err, "ACT25 TOGGLE bool/quad variable %s", buf->data);
        if (DTYPE(he->type) == DT_BOOL)
          bool_he_toggle(Config, he, err);
        else
          quad_he_toggle(Config, he, err);
      }
      else
      {
        // mutt_buffer_printf(err, "ACT26 UNSET bool/quad variable %s", buf->data);
        rc = cs_he_native_set(Config, he, false, err);
        if (CSR_RESULT(rc) != CSR_SUCCESS)
          return MUTT_CMD_ERROR;
      }
      continue;
    }
    else
    {
      rc = cs_he_string_set(Config, he, NULL, err);
      if (CSR_RESULT(rc) != CSR_SUCCESS)
        return MUTT_CMD_ERROR;
    }
  }

  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

parse_setenv()

static enum CommandResult parse_setenv ( struct Buffer *  buf, struct Buffer *  s, unsigned long  data, struct Buffer *  err  )

static

Parse the 'setenv' and 'unsetenv' commands - Implements command_t.

Definition at line 1842 of file init.c.

{
  char **envp = mutt_envlist_getlist();

  bool query = false;
  bool unset = (data == MUTT_SET_UNSET);

  if (!MoreArgs(s))
  {
    mutt_buffer_printf(err, _("%s: too few arguments"), "setenv");
    return MUTT_CMD_WARNING;
  }

  if (*s->dptr == '?')
  {
    query = true;
    s->dptr++;
  }

  /* get variable name */
  mutt_extract_token(buf, s, MUTT_TOKEN_EQUAL);

  if (query)
  {
    bool found = false;
    while (envp && *envp)
    {
      /* This will display all matches for "^QUERY" */
      if (mutt_str_startswith(*envp, buf->data, CASE_MATCH))
      {
        if (!found)
        {
          mutt_endwin();
          found = true;
        }
        puts(*envp);
      }
      envp++;
    }

    if (found)
    {
      mutt_any_key_to_continue(NULL);
      return MUTT_CMD_SUCCESS;
    }

    mutt_buffer_printf(err, _("%s is unset"), buf->data);
    return MUTT_CMD_WARNING;
  }

  if (unset)
  {
    if (mutt_envlist_unset(buf->data))
      return MUTT_CMD_SUCCESS;
    return MUTT_CMD_ERROR;
  }

  /* set variable */

  if (*s->dptr == '=')
  {
    s->dptr++;
    SKIPWS(s->dptr);
  }

  if (!MoreArgs(s))
  {
    mutt_buffer_printf(err, _("%s: too few arguments"), "setenv");
    return MUTT_CMD_WARNING;
  }

  char *name = mutt_str_strdup(buf->data);
  mutt_extract_token(buf, s, MUTT_TOKEN_NO_FLAGS);
  mutt_envlist_set(name, buf->data, true);
  FREE(&name);

  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

parse_source()

static enum CommandResult parse_source ( struct Buffer *  buf, struct Buffer *  s, unsigned long  data, struct Buffer *  err  )

static

Parse the 'source' command - Implements command_t.

Definition at line 1925 of file init.c.

{
  char path[PATH_MAX];

  do
  {
    if (mutt_extract_token(buf, s, MUTT_TOKEN_NO_FLAGS) != 0)
    {
      mutt_buffer_printf(err, _("source: error at %s"), s->dptr);
      return MUTT_CMD_ERROR;
    }
    mutt_str_strfcpy(path, buf->data, sizeof(path));
    mutt_expand_path(path, sizeof(path));

    if (source_rc(path, err) < 0)
    {
      mutt_buffer_printf(err, _("source: file %s could not be sourced"), path);
      return MUTT_CMD_ERROR;
    }

  } while (MoreArgs(s));

  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

parse_spam_list()

static enum CommandResult parse_spam_list ( struct Buffer *  buf, struct Buffer *  s, unsigned long  data, struct Buffer *  err  )

static

Parse the 'spam' and 'nospam' commands - Implements command_t.

Definition at line 1954 of file init.c.

{
  struct Buffer templ;

  mutt_buffer_init(&templ);

  /* Insist on at least one parameter */
  if (!MoreArgs(s))
  {
    if (data == MUTT_SPAM)
      mutt_buffer_strcpy(err, _("spam: no matching pattern"));
    else
      mutt_buffer_strcpy(err, _("nospam: no matching pattern"));
    return MUTT_CMD_ERROR;
  }

  /* Extract the first token, a regex */
  mutt_extract_token(buf, s, MUTT_TOKEN_NO_FLAGS);

  /* data should be either MUTT_SPAM or MUTT_NOSPAM. MUTT_SPAM is for spam commands. */
  if (data == MUTT_SPAM)
  {
    /* If there's a second parameter, it's a template for the spam tag. */
    if (MoreArgs(s))
    {
      mutt_extract_token(&templ, s, MUTT_TOKEN_NO_FLAGS);

      /* Add to the spam list. */
      if (mutt_replacelist_add(&SpamList, buf->data, templ.data, err) != 0)
      {
        FREE(&templ.data);
        return MUTT_CMD_ERROR;
      }
      FREE(&templ.data);
    }
    /* If not, try to remove from the nospam list. */
    else
    {
      mutt_regexlist_remove(&NoSpamList, buf->data);
    }

    return MUTT_CMD_SUCCESS;
  }
  /* MUTT_NOSPAM is for nospam commands. */
  else if (data == MUTT_NOSPAM)
  {
    /* nospam only ever has one parameter. */

    /* "*" is a special case. */
    if (mutt_str_strcmp(buf->data, "*") == 0)
    {
      mutt_replacelist_free(&SpamList);
      mutt_regexlist_free(&NoSpamList);
      return MUTT_CMD_SUCCESS;
    }

    /* If it's on the spam list, just remove it. */
    if (mutt_replacelist_remove(&SpamList, buf->data) != 0)
      return MUTT_CMD_SUCCESS;

    /* Otherwise, add it to the nospam list. */
    if (mutt_regexlist_add(&NoSpamList, buf->data, REG_ICASE, err) != 0)
      return MUTT_CMD_ERROR;

    return MUTT_CMD_SUCCESS;
  }

  /* This should not happen. */
  mutt_buffer_strcpy(err, "This is no good at all.");
  return MUTT_CMD_ERROR;
}

Here is the call graph for this function:

parse_stailq()

static enum CommandResult parse_stailq ( struct Buffer *  buf, struct Buffer *  s, unsigned long  data, struct Buffer *  err  )

static

Parse a list command - Implements command_t.

This is used by 'alternative_order', 'auto_view' and several others.

Definition at line 2032 of file init.c.

{
  do
  {
    mutt_extract_token(buf, s, MUTT_TOKEN_NO_FLAGS);
    add_to_stailq((struct ListHead *) data, buf->data);
  } while (MoreArgs(s));

  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

parse_subjectrx_list()

static enum CommandResult parse_subjectrx_list ( struct Buffer *  buf, struct Buffer *  s, unsigned long  data, struct Buffer *  err  )

static

Parse the 'subjectrx' command - Implements command_t.

Definition at line 2047 of file init.c.

{
  enum CommandResult rc;

  rc = parse_replace_list(buf, s, data, err);
  if (rc == MUTT_CMD_SUCCESS)
    clear_subject_mods();
  return rc;
}

Here is the call graph for this function:

parse_subscribe()

static enum CommandResult parse_subscribe ( struct Buffer *  buf, struct Buffer *  s, unsigned long  data, struct Buffer *  err  )

static

Parse the 'subscribe' command - Implements command_t.

Definition at line 2061 of file init.c.

{
  struct GroupList gl = STAILQ_HEAD_INITIALIZER(gl);

  do
  {
    mutt_extract_token(buf, s, MUTT_TOKEN_NO_FLAGS);

    if (parse_grouplist(&gl, buf, s, data, err) == -1)
      goto bail;

    mutt_regexlist_remove(&UnMailLists, buf->data);
    mutt_regexlist_remove(&UnSubscribedLists, buf->data);

    if (mutt_regexlist_add(&MailLists, buf->data, REG_ICASE, err) != 0)
      goto bail;
    if (mutt_regexlist_add(&SubscribedLists, buf->data, REG_ICASE, err) != 0)
      goto bail;
    if (mutt_grouplist_add_regex(&gl, buf->data, REG_ICASE, err) != 0)
      goto bail;
  } while (MoreArgs(s));

  mutt_grouplist_destroy(&gl);
  return MUTT_CMD_SUCCESS;

bail:
  mutt_grouplist_destroy(&gl);
  return MUTT_CMD_ERROR;
}

Here is the call graph for this function:

parse_subscribe_to()

static enum CommandResult parse_subscribe_to ( struct Buffer *  buf, struct Buffer *  s, unsigned long  data, struct Buffer *  err  )

static

Parse the 'subscribe-to' command - Implements command_t.

The 'subscribe-to' command allows to subscribe to an IMAP-Mailbox. Patterns are not supported. Use it as follows: subscribe-to =folder

Definition at line 2100 of file init.c.

{
  if (!buf || !s || !err)
    return MUTT_CMD_ERROR;

  mutt_buffer_reset(err);

  if (MoreArgs(s))
  {
    mutt_extract_token(buf, s, MUTT_TOKEN_NO_FLAGS);

    if (MoreArgs(s))
    {
      mutt_buffer_printf(err, _("%s: too many arguments"), "subscribe-to");
      return MUTT_CMD_WARNING;
    }

    if (buf->data && (*buf->data != '\0'))
    {
      /* Expand and subscribe */
      if (imap_subscribe(mutt_expand_path(buf->data, buf->dsize), true) == 0)
      {
        mutt_message(_("Subscribed to %s"), buf->data);
        return MUTT_CMD_SUCCESS;
      }

      mutt_buffer_printf(err, _("Could not subscribe to %s"), buf->data);
      return MUTT_CMD_ERROR;
    }

    mutt_debug(LL_DEBUG1, "Corrupted buffer");
    return MUTT_CMD_ERROR;
  }

  mutt_buffer_addstr(err, _("No folder specified"));
  return MUTT_CMD_WARNING;
}

Here is the call graph for this function:

parse_tag_formats()

static enum CommandResult parse_tag_formats ( struct Buffer *  buf, struct Buffer *  s, unsigned long  data, struct Buffer *  err  )

static

Parse the 'tag-formats' command - Implements command_t.

Definition at line 2143 of file init.c.

{
  if (!buf || !s)
    return MUTT_CMD_ERROR;

  char *tmp = NULL;

  while (MoreArgs(s))
  {
    char *tag = NULL, *format = NULL;

    mutt_extract_token(buf, s, MUTT_TOKEN_NO_FLAGS);
    if (buf->data && (*buf->data != '\0'))
      tag = mutt_str_strdup(buf->data);
    else
      continue;

    mutt_extract_token(buf, s, MUTT_TOKEN_NO_FLAGS);
    format = mutt_str_strdup(buf->data);

    /* avoid duplicates */
    tmp = mutt_hash_find(TagFormats, format);
    if (tmp)
    {
      mutt_debug(LL_DEBUG3, "tag format '%s' already registered as '%s'\n", format, tmp);
      FREE(&tag);
      FREE(&format);
      continue;
    }

    mutt_hash_insert(TagFormats, format, tag);
  }
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

parse_tag_transforms()

static enum CommandResult parse_tag_transforms ( struct Buffer *  buf, struct Buffer *  s, unsigned long  data, struct Buffer *  err  )

static

Parse the 'tag-transforms' command - Implements command_t.

Definition at line 2182 of file init.c.

{
  if (!buf || !s)
    return MUTT_CMD_ERROR;

  char *tmp = NULL;

  while (MoreArgs(s))
  {
    char *tag = NULL, *transform = NULL;

    mutt_extract_token(buf, s, MUTT_TOKEN_NO_FLAGS);
    if (buf->data && (*buf->data != '\0'))
      tag = mutt_str_strdup(buf->data);
    else
      continue;

    mutt_extract_token(buf, s, MUTT_TOKEN_NO_FLAGS);
    transform = mutt_str_strdup(buf->data);

    /* avoid duplicates */
    tmp = mutt_hash_find(TagTransforms, tag);
    if (tmp)
    {
      mutt_debug(LL_DEBUG3, "tag transform '%s' already registered as '%s'\n", tag, tmp);
      FREE(&tag);
      FREE(&transform);
      continue;
    }

    mutt_hash_insert(TagTransforms, tag, transform);
  }
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

parse_unalias()

static enum CommandResult parse_unalias ( struct Buffer *  buf, struct Buffer *  s, unsigned long  data, struct Buffer *  err  )

static

Parse the 'unalias' command - Implements command_t.

Definition at line 2221 of file init.c.

{
  struct Alias *a = NULL;

  do
  {
    mutt_extract_token(buf, s, MUTT_TOKEN_NO_FLAGS);

    if (mutt_str_strcmp("*", buf->data) == 0)
    {
      if (CurrentMenu == MENU_ALIAS)
      {
        TAILQ_FOREACH(a, &Aliases, entries)
        {
          a->del = true;
        }
        mutt_menu_set_current_redraw_full();
      }
      else
        mutt_aliaslist_free(&Aliases);
      break;
    }
    else
    {
      TAILQ_FOREACH(a, &Aliases, entries)
      {
        if (mutt_str_strcasecmp(buf->data, a->name) == 0)
        {
          if (CurrentMenu == MENU_ALIAS)
          {
            a->del = true;
            mutt_menu_set_current_redraw_full();
          }
          else
          {
            TAILQ_REMOVE(&Aliases, a, entries);
            mutt_alias_free(&a);
          }
          break;
        }
      }
    }
  } while (MoreArgs(s));
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

parse_unalternates()

static enum CommandResult parse_unalternates ( struct Buffer *  buf, struct Buffer *  s, unsigned long  data, struct Buffer *  err  )

static

Parse the 'unalternates' command - Implements command_t.

Definition at line 2271 of file init.c.

{
  alternates_clean();
  do
  {
    mutt_extract_token(buf, s, MUTT_TOKEN_NO_FLAGS);
    mutt_regexlist_remove(&Alternates, buf->data);

    if ((mutt_str_strcmp(buf->data, "*") != 0) &&
        (mutt_regexlist_add(&UnAlternates, buf->data, REG_ICASE, err) != 0))
    {
      return MUTT_CMD_ERROR;
    }

  } while (MoreArgs(s));

  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

mutt_attachmatch_free()

void mutt_attachmatch_free

(

struct AttachMatch **

ptr

)

Free an AttachMatch - Implements list_free_t.

Parameters

ptr	AttachMatch to free

Note

We don't free minor because it is either a pointer into major, or a static string.

Definition at line 2298 of file init.c.

{
  if (!ptr || !*ptr)
    return;

  struct AttachMatch *am = *ptr;
  regfree(&am->minor_regex);
  FREE(&am->major);
  FREE(ptr);
}

Here is the caller graph for this function:

parse_unattachments()

static enum CommandResult parse_unattachments ( struct Buffer *  buf, struct Buffer *  s, unsigned long  data, struct Buffer *  err  )

static

Parse the 'unattachments' command - Implements command_t.

Definition at line 2312 of file init.c.

{
  char op;
  char *p = NULL;
  struct ListHead *head = NULL;

  mutt_extract_token(buf, s, MUTT_TOKEN_NO_FLAGS);
  if (!buf->data || (*buf->data == '\0'))
  {
    mutt_buffer_strcpy(err, _("unattachments: no disposition"));
    return MUTT_CMD_WARNING;
  }

  p = buf->data;
  op = *p++;

  if (op == '*')
  {
    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);
    attachments_clean();
    return 0;
  }

  if ((op != '+') && (op != '-'))
  {
    op = '+';
    p--;
  }
  if (mutt_str_startswith("attachment", p, CASE_IGNORE))
  {
    if (op == '+')
      head = &AttachAllow;
    else
      head = &AttachExclude;
  }
  else if (mutt_str_startswith("inline", p, CASE_IGNORE))
  {
    if (op == '+')
      head = &InlineAllow;
    else
      head = &InlineExclude;
  }
  else
  {
    mutt_buffer_strcpy(err, _("unattachments: invalid disposition"));
    return MUTT_CMD_ERROR;
  }

  return parse_unattach_list(buf, s, head, err);
}

Here is the call graph for this function:

parse_unignore()

static enum CommandResult parse_unignore ( struct Buffer *  buf, struct Buffer *  s, unsigned long  data, struct Buffer *  err  )

static

Parse the 'unignore' command - Implements command_t.

Definition at line 2370 of file init.c.

{
  do
  {
    mutt_extract_token(buf, s, MUTT_TOKEN_NO_FLAGS);

    /* don't add "*" to the unignore list */
    if (strcmp(buf->data, "*") != 0)
      add_to_stailq(&UnIgnore, buf->data);

    remove_from_stailq(&Ignore, buf->data);
  } while (MoreArgs(s));

  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

parse_unlists()

static enum CommandResult parse_unlists ( struct Buffer *  buf, struct Buffer *  s, unsigned long  data, struct Buffer *  err  )

static

Parse the 'unlists' command - Implements command_t.

Definition at line 2390 of file init.c.

{
  mutt_hash_free(&AutoSubscribeCache);
  do
  {
    mutt_extract_token(buf, s, MUTT_TOKEN_NO_FLAGS);
    mutt_regexlist_remove(&SubscribedLists, buf->data);
    mutt_regexlist_remove(&MailLists, buf->data);

    if ((mutt_str_strcmp(buf->data, "*") != 0) &&
        (mutt_regexlist_add(&UnMailLists, buf->data, REG_ICASE, err) != 0))
    {
      return MUTT_CMD_ERROR;
    }
  } while (MoreArgs(s));

  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

parse_unmailboxes()

static enum CommandResult parse_unmailboxes ( struct Buffer *  buf, struct Buffer *  s, unsigned long  data, struct Buffer *  err  )

static

Parse the 'unmailboxes' command - Implements command_t.

This is also used by 'unvirtual-mailboxes'

Definition at line 2415 of file init.c.

{
  bool tmp_valid = false;
  bool clear_all = false;

  while (!clear_all && MoreArgs(s))
  {
    mutt_extract_token(buf, s, MUTT_TOKEN_NO_FLAGS);

    if (mutt_str_strcmp(buf->data, "*") == 0)
    {
      clear_all = true;
      tmp_valid = false;
    }
    else
    {
      mutt_buffer_expand_path(buf);
      tmp_valid = true;
    }

    struct MailboxList ml = neomutt_mailboxlist_get_all(NeoMutt, MUTT_MAILBOX_ANY);
    struct MailboxNode *np = NULL;
    struct MailboxNode *nptmp = NULL;
    STAILQ_FOREACH_SAFE(np, &ml, entries, nptmp)
    {
      /* Decide whether to delete all normal mailboxes or all virtual */
      bool virt = ((np->mailbox->magic == MUTT_NOTMUCH) && (data & MUTT_VIRTUAL));
      bool norm = ((np->mailbox->magic != MUTT_NOTMUCH) && !(data & MUTT_VIRTUAL));
      bool clear_this = clear_all && (virt || norm);

      /* Compare against path or desc? Ensure 'buf' is valid */
      if (!clear_this && tmp_valid)
      {
        clear_this =
            (mutt_str_strcasecmp(mutt_b2s(buf), mailbox_path(np->mailbox)) == 0) ||
            (mutt_str_strcasecmp(mutt_b2s(buf), np->mailbox->name) == 0);
      }

      if (clear_this)
      {
#ifdef USE_SIDEBAR
        mutt_sb_notify_mailbox(np->mailbox, false);
#endif
#ifdef USE_INOTIFY
        mutt_monitor_remove(np->mailbox);
#endif
        if (Context && (Context->mailbox == np->mailbox))
        {
          np->mailbox->flags |= MB_HIDDEN;
        }
        else
        {
          account_mailbox_remove(np->mailbox->account, np->mailbox);
          mailbox_free(&np->mailbox);
        }
      }
    }
    neomutt_mailboxlist_clear(&ml);
  }
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

parse_unmy_hdr()

static enum CommandResult parse_unmy_hdr ( struct Buffer *  buf, struct Buffer *  s, unsigned long  data, struct Buffer *  err  )

static

Parse the 'unmy_hdr' command - Implements command_t.

Definition at line 2481 of file init.c.

{
  struct ListNode *np = NULL, *tmp = NULL;
  size_t l;

  do
  {
    mutt_extract_token(buf, s, MUTT_TOKEN_NO_FLAGS);
    if (mutt_str_strcmp("*", buf->data) == 0)
    {
      mutt_list_free(&UserHeader);
      continue;
    }

    l = mutt_str_strlen(buf->data);
    if (buf->data[l - 1] == ':')
      l--;

    STAILQ_FOREACH_SAFE(np, &UserHeader, entries, tmp)
    {
      if ((mutt_str_strncasecmp(buf->data, np->data, l) == 0) && (np->data[l] == ':'))
      {
        STAILQ_REMOVE(&UserHeader, np, ListNode, entries);
        FREE(&np->data);
        FREE(&np);
      }
    }
  } while (MoreArgs(s));
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

parse_unstailq()

static enum CommandResult parse_unstailq ( struct Buffer *  buf, struct Buffer *  s, unsigned long  data, struct Buffer *  err  )

static

Parse an unlist command - Implements command_t.

This is used by 'unalternative_order', 'unauto_view' and several others.

Definition at line 2518 of file init.c.

{
  do
  {
    mutt_extract_token(buf, s, MUTT_TOKEN_NO_FLAGS);
    /* Check for deletion of entire list */
    if (mutt_str_strcmp(buf->data, "*") == 0)
    {
      mutt_list_free((struct ListHead *) data);
      break;
    }
    remove_from_stailq((struct ListHead *) data, buf->data);
  } while (MoreArgs(s));

  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

parse_unsubjectrx_list()

static enum CommandResult parse_unsubjectrx_list ( struct Buffer *  buf, struct Buffer *  s, unsigned long  data, struct Buffer *  err  )

static

Parse the 'unsubjectrx' command - Implements command_t.

Definition at line 2539 of file init.c.

{
  enum CommandResult rc;

  rc = parse_unreplace_list(buf, s, data, err);
  if (rc == MUTT_CMD_SUCCESS)
    clear_subject_mods();
  return rc;
}

Here is the call graph for this function:

parse_unsubscribe()

static enum CommandResult parse_unsubscribe ( struct Buffer *  buf, struct Buffer *  s, unsigned long  data, struct Buffer *  err  )

static

Parse the 'unsubscribe' command - Implements command_t.

Definition at line 2553 of file init.c.

{
  mutt_hash_free(&AutoSubscribeCache);
  do
  {
    mutt_extract_token(buf, s, MUTT_TOKEN_NO_FLAGS);
    mutt_regexlist_remove(&SubscribedLists, buf->data);

    if ((mutt_str_strcmp(buf->data, "*") != 0) &&
        (mutt_regexlist_add(&UnSubscribedLists, buf->data, REG_ICASE, err) != 0))
    {
      return MUTT_CMD_ERROR;
    }
  } while (MoreArgs(s));

  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

parse_unsubscribe_from()

static enum CommandResult parse_unsubscribe_from ( struct Buffer *  buf, struct Buffer *  s, unsigned long  data, struct Buffer *  err  )

static

Parse the 'unsubscribe-from' command - Implements command_t.

The 'unsubscribe-from' command allows to unsubscribe from an IMAP-Mailbox. Patterns are not supported. Use it as follows: unsubscribe-from =folder

Definition at line 2580 of file init.c.

{
  if (!buf || !s || !err)
    return MUTT_CMD_ERROR;

  if (MoreArgs(s))
  {
    mutt_extract_token(buf, s, MUTT_TOKEN_NO_FLAGS);

    if (MoreArgs(s))
    {
      mutt_buffer_printf(err, _("%s: too many arguments"), "unsubscribe-from");
      return MUTT_CMD_WARNING;
    }

    if (buf->data && (*buf->data != '\0'))
    {
      /* Expand and subscribe */
      if (imap_subscribe(mutt_expand_path(buf->data, buf->dsize), false) == 0)
      {
        mutt_message(_("Unsubscribed from %s"), buf->data);
        return MUTT_CMD_SUCCESS;
      }

      mutt_buffer_printf(err, _("Could not unsubscribe from %s"), buf->data);
      return MUTT_CMD_ERROR;
    }

    mutt_debug(LL_DEBUG1, "Corrupted buffer");
    return MUTT_CMD_ERROR;
  }

  mutt_buffer_addstr(err, _("No folder specified"));
  return MUTT_CMD_WARNING;
}

Here is the call 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 2624 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_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 2655 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 = mutt_create_filter(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);
      mutt_wait_filter(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_str_string_get(Config, 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 2890 of file init.c.

{
  mutt_list_free(&MuttrcStack);

  FREE(&Matches);

  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);
  mutt_list_free(&MuttrcStack);
#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 2957 of file init.c.

{
  for (const struct Command *c = Commands; c->name; c++)
  {
    if (((c->func == mutt_parse_hook) || (c->func == 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	(	bool	skip_sys_rc,
		struct ListHead *	commands
	)

Initialise NeoMutt.

Parameters

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 2977 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();
&#