source.c File Reference

Parse Source Commands. More...

#include "config.h"
#include <errno.h>
#include <limits.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "core/lib.h"
#include "source.h"
#include "parse/lib.h"
#include "module_data.h"
#include "muttlib.h"
#include <libintl.h>

Include dependency graph for source.c:

Go to the source code of this file.

Macros
#define	MAX_ERRS   128

Functions
int	source_rc (const char *rcfile_path, struct ParseContext *pc, struct ParseError *pe)
	Read an initialization file.
enum CommandResult	parse_source (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'source' command - Implements Command::parse() -.
void	source_stack_cleanup (void)
	Free memory from the stack used for the source command.
enum CommandResult	parse_rc_line_cwd (const char *line, char *cwd, struct ParseContext *pc, struct ParseError *pe)
	Parse and run a muttrc line in a relative directory.
char *	mutt_get_sourced_cwd (void)
	Get the current file path that is being parsed.

Detailed Description

Parse Source Commands.

Authors

• Michael R. Elkins
• g10 Code GmbH
• Richard Russon
• Aditya De Saha
• Matthew Hughes
• R Primus
• Pietro Cerutti
• Marco Sirabella
• Dennis Schön

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

Macro Definition Documentation

MAX_ERRS

#define MAX_ERRS   128

Definition at line 55 of file source.c.

Function Documentation

source_rc()

int source_rc	(	const char *	rcfile_path,
		struct ParseContext *	pc,
		struct ParseError *	pe )

Read an initialization file.

Parameters

rcfile_path	Path to initialization file
pc	Parse Context
pe	Parse Errors

Return values

<0	NeoMutt should pause to let the user know

Definition at line 64 of file source.c.

{
  if (!rcfile_path || !pc || !pe)
    return -1;
 
  struct CommandsModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_COMMANDS);
  struct Buffer *err = pe->message;
 
  int lineno = 0, rc = 0, warnings = 0;
  enum CommandResult line_rc;
  struct Buffer *linebuf = NULL;
  char *line = NULL;
  char *currentline = NULL;
  char rcfile[PATH_MAX + 1] = { 0 };
  size_t linelen = 0;
  pid_t pid;
 
  mutt_str_copy(rcfile, rcfile_path, sizeof(rcfile));
 
  size_t rcfilelen = mutt_str_len(rcfile);
  if (rcfilelen == 0)
    return -1;
 
  bool ispipe = rcfile[rcfilelen - 1] == '|';
 
  if (!ispipe)
  {
    struct ListNode *np = STAILQ_FIRST(&mod_data->muttrc_stack);
    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, &mod_data->muttrc_stack, entries)
    {
      if (mutt_str_equal(np->data, rcfile))
      {
        break;
      }
    }
    if (np)
    {
      mutt_error(_("Error: Cyclic sourcing of configuration file '%s'"), rcfile);
      return -1;
    }
 
    mutt_list_insert_head(&mod_data->muttrc_stack, mutt_str_dup(rcfile));
  }
 
  mutt_debug(LL_DEBUG2, "Reading configuration file '%s'\n", rcfile);
 
  FILE *fp = mutt_open_read(rcfile, &pid);
  if (!fp)
  {
    buf_printf(err, "%s: %s", rcfile, strerror(errno));
    return -1;
  }
 
  linebuf = buf_pool_get();
 
  const char *const c_config_charset = cs_subset_string(NeoMutt->sub, "config_charset");
  const char *const c_charset = cc_charset();
  while ((line = mutt_file_read_line(line, &linelen, fp, &lineno, MUTT_RL_CONT)) != NULL)
  {
    const bool conv = c_config_charset && c_charset;
    if (conv)
    {
      currentline = mutt_str_dup(line);
      if (!currentline)
        continue;
      mutt_ch_convert_string(&currentline, c_config_charset, c_charset, MUTT_ICONV_NONE);
    }
    else
    {
      currentline = line;
    }
 
    buf_strcpy(linebuf, currentline);
 
    buf_reset(err);
    line_rc = parse_rc_line(linebuf, pc, pe);
    if (line_rc == MUTT_CMD_ERROR)
    {
      mutt_error("%s:%d: %s", rcfile, lineno, buf_string(err));
      if (--rc < -MAX_ERRS)
      {
        if (conv)
          FREE(&currentline);
        break;
      }
    }
    else if (line_rc == MUTT_CMD_WARNING)
    {
      /* Warning */
      mutt_warning("%s:%d: %s", rcfile, lineno, buf_string(err));
      warnings++;
    }
    else if (line_rc == MUTT_CMD_FINISH)
    {
      if (conv)
        FREE(&currentline);
      break; /* Found "finish" command */
    }
    else
    {
      if (rc < 0)
        rc = -1;
    }
    if (conv)
      FREE(&currentline);
  }
 
  FREE(&line);
  mutt_file_fclose(&fp);
  if (ispipe && (pid != -1))
  {
    int status = filter_wait(pid);
    if (status != 0)
    {
      mutt_error(_("Command '%s' exited with status %d"), rcfile, status);
      if (rc == 0)
        rc = -1; // Set error code if not already set
    }
  }
 
  if (rc)
  {
    /* the neomuttrc source keyword */
    buf_reset(err);
    buf_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)
    {
      buf_printf(err, ngettext("source: %d warning in %s", "source: %d warnings in %s", warnings),
                 warnings, rcfile);
      rc = -2;
    }
  }
 
  if (!ispipe && !STAILQ_EMPTY(&mod_data->muttrc_stack))
  {
    struct ListNode *np = STAILQ_FIRST(&mod_data->muttrc_stack);
    STAILQ_REMOVE_HEAD(&mod_data->muttrc_stack, entries);
    FREE(&np->data);
    FREE(&np);
  }
 
  buf_pool_release(&linebuf);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

source_stack_cleanup()

void source_stack_cleanup

(

void

)

Free memory from the stack used for the source command.

Definition at line 272 of file source.c.

{
  struct CommandsModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_COMMANDS);
  if (mod_data)
    mutt_list_free(&mod_data->muttrc_stack);
}

Here is the call graph for this function:

Here is the caller graph for this function:

parse_rc_line_cwd()

enum CommandResult parse_rc_line_cwd	(	const char *	line,
		char *	cwd,
		struct ParseContext *	pc,
		struct ParseError *	pe )

Parse and run a muttrc line in a relative directory.

Parameters

line	Line to be parsed
cwd	File relative where to run the line
pc	Parse Context
pe	Parse Errors

Return values

CommandResult

Result e.g. MUTT_CMD_SUCCESS

Definition at line 287 of file source.c.

{
  if (!line || !cwd || !pc || !pe)
    return MUTT_CMD_ERROR;
 
  struct CommandsModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_COMMANDS);
  mutt_list_insert_head(&mod_data->muttrc_stack, mutt_str_dup(NONULL(cwd)));
 
  struct Buffer *buf = buf_pool_get();
  buf_strcpy(buf, line);
  enum CommandResult ret = parse_rc_line(buf, pc, pe);
  buf_pool_release(&buf);
 
  struct ListNode *np = STAILQ_FIRST(&mod_data->muttrc_stack);
  STAILQ_REMOVE_HEAD(&mod_data->muttrc_stack, entries);
  FREE(&np->data);
  FREE(&np);
 
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_get_sourced_cwd()

char * mutt_get_sourced_cwd

(

void

)

Get the current file path that is being parsed.

Return values

ptr	File path that is being parsed or cwd at runtime

Note

Caller is responsible for freeing returned string

Definition at line 315 of file source.c.

{
  struct CommandsModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_COMMANDS);
  struct ListNode *np = STAILQ_FIRST(&mod_data->muttrc_stack);
  if (np && np->data)
    return mutt_str_dup(np->data);
 
  // stack is empty, return our own dummy file relative to cwd
  struct Buffer *cwd = buf_pool_get();
  mutt_path_getcwd(cwd);
  buf_addstr(cwd, "/dummy.rc");
  char *ret = buf_strdup(cwd);
  buf_pool_release(&cwd);
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function: