source.c

Go to the documentation of this file.

 
#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"
#ifdef ENABLE_NLS
#include <libintl.h>
#endif
 
#define MAX_ERRS 128

int source_rc(const char *rcfile_path, struct ParseContext *pc, struct ParseError *pe)
{
  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;
}

enum CommandResult parse_source(const struct Command *cmd, struct Buffer *line,
                                const struct ParseContext *pc, struct ParseError *pe)
{
  struct Buffer *err = pe->message;
 
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct Buffer *token = buf_pool_get();
  struct Buffer *path = buf_pool_get();
  enum CommandResult rc = MUTT_CMD_ERROR;
 
  do
  {
    if (parse_extract_token(token, line, TOKEN_BACKTICK_VARS) != 0)
    {
      buf_printf(err, _("source: error at %s"), line->dptr);
      goto done;
    }
    buf_copy(path, token);
    expand_path(path, false);
 
    // Cheat: Remove the `const` so we can recurse
    if (source_rc(buf_string(path), (struct ParseContext *) pc, pe) < 0)
    {
      buf_printf(err, _("source: file %s could not be sourced"), buf_string(path));
      goto done;
    }
 
  } while (MoreArgs(line));
 
  rc = MUTT_CMD_SUCCESS;
 
done:
  buf_pool_release(&path);
  buf_pool_release(&token);
  return rc;
}

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

enum CommandResult parse_rc_line_cwd(const char *line, char *cwd,
                                     struct ParseContext *pc, struct ParseError *pe)
{
  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;
}

char *mutt_get_sourced_cwd(void)
{
  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;
}