/*

 * settings.c   -- Configuration stuff

 *

 * Copyright (C) 2005-2015 Mikael Berthe <mikael@lilotux.net>

 *

 * 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, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307

 * USA

 */

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <sys/stat.h>

#include "config.h"

#include "settings.h"

#include "commands.h"

#include "logprint.h"

#include "otr.h"

#include "utils.h"

#include "xmpp.h"

#include "main.h"

// Maximum line length

// (probably best to use the same value as INPUTLINE_LENGTH)

#define CONFLINE_LENGTH  1024

static GHashTable *option;

static GHashTable *alias;

static GHashTable *binding;

static GHashTable *guards;

#ifdef HAVE_GPGME     /* PGP settings */

static GHashTable *pgpopt;

typedef struct {

  gchar *pgp_keyid;   /* KeyId the contact is supposed to use */

  guint pgp_disabled; /* If TRUE, PGP is disabled for outgoing messages */

  guint pgp_force;    /* If TRUE, PGP is used w/o negotiation */

} T_pgpopt;

#endif

typedef struct {

  settings_guard_t guard;

} installed_guard_t;

#ifdef HAVE_LIBOTR

static GHashTable *otrpolicy;

static enum otr_policy default_policy;

#endif

static inline GHashTable *get_hash(guint type)

{

  if      (type == SETTINGS_TYPE_OPTION)  return option;

  else if (type == SETTINGS_TYPE_ALIAS)   return alias;

  else if (type == SETTINGS_TYPE_BINDING) return binding;

#ifdef HAVE_LIBOTR

  else if (type == SETTINGS_TYPE_OTR)     return otrpolicy;

#endif

  return NULL;

}

/* -- */

void settings_init(void)

{

  option  = g_hash_table_new_full(&g_str_hash, &g_str_equal, &g_free, &g_free);

  alias   = g_hash_table_new_full(&g_str_hash, &g_str_equal, &g_free, &g_free);

  binding = g_hash_table_new_full(&g_str_hash, &g_str_equal, &g_free, &g_free);

  guards  = g_hash_table_new_full(&g_str_hash, &g_str_equal, &g_free, &g_free);

#ifdef HAVE_GPGME

  pgpopt = g_hash_table_new(&g_str_hash, &g_str_equal);

#endif

#ifdef HAVE_LIBOTR

  otrpolicy = g_hash_table_new(&g_str_hash, &g_str_equal);

#endif

}

//  settings_get_mcabber_config_dir()

// Returns the mcabber configuration directory.

// The directory is looked up for only once (and the string is never freed,

// but we might change this later).

const gchar *settings_get_mcabber_config_dir(void)

{

  static char *config_dir;

  GString *sfilename;

  FILE *fp;

  if (config_dir)

    return config_dir;

  home_dir = getenv("HOME");

  if (!home_dir) {

    scr_log_print(LPRINT_LOG, "Can't find home dir!");

    fprintf(stderr, "Can't find home dir!\n");

    return NULL;

  }

  sfilename = g_string_new("");

  // First try: $HOME/.mcabber/mcabberrc

  g_string_printf(sfilename, "%s/.mcabber/mcabberrc", home_dir);

  if ((fp = fopen(sfilename->str, "r")) != NULL) {

    fclose(fp);

    config_dir = g_strdup_printf("%s/.mcabber", home_dir);

  }

  // Second guess: Try to use the XDG standard configuration directory

  if (!config_dir) {

    char *xdg_config_dir = g_strdup(getenv("XDG_CONFIG_HOME"));

    if (!xdg_config_dir || !*xdg_config_dir) {

      // Free the string if it is non-null but empty

      if (xdg_config_dir) g_free(xdg_config_dir);

      xdg_config_dir = g_strdup_printf("%s/.config", home_dir);

    }

    if (xdg_config_dir) {

      int fd = -1;

      struct stat statbuf;

      if (*xdg_config_dir)

        fd = stat(xdg_config_dir, &statbuf);

      // If the XDG configuration directory exists, see if we can find a

      // configuration file for mcabber inside.

      if (fd != -1) {

        char *xdg_mcabber_dir = g_strdup_printf("%s/mcabber", xdg_config_dir);

        g_string_printf(sfilename, "%s/mcabberrc", xdg_mcabber_dir);

        if ((fp = fopen(sfilename->str, "r")) != NULL) {

          fclose(fp);

          config_dir = xdg_mcabber_dir;

        } else {

          g_free(xdg_mcabber_dir);

        }

      }

      g_free(xdg_config_dir);

    }

  }

  g_string_free(sfilename, TRUE);

  return config_dir;

}

//  cfg_read_file(filename, mainfile)

// Read and parse config file "filename".  If filename is NULL,

// try to open the configuration file at the default locations.

// mainfile must be set to TRUE for the startup config file.

// If mainfile is TRUE, the permissions of the configuration file will

// be fixed if they're insecure.

//

int cfg_read_file(char *filename, guint mainfile)

{

  static unsigned int runtime;

  FILE *fp;

  char *buf;

  char *line, *eol;

  unsigned int ln = 0;

  int err = 0;

  if (!filename) {

    const gchar *mcabber_conf_dir;

    gchar *def_filename;

    if (!mainfile) {

      scr_LogPrint(LPRINT_LOGNORM, "No file name provided");

      return -1;

    }

    mcabber_conf_dir = settings_get_mcabber_config_dir();

    if ((fp = fopen(def_filename, "r")) == NULL) {

      fprintf(stderr, "Cannot open config file!\n");

      g_free(def_filename);

      err = -1;

      goto cfg_read_file_return;

    }

    // Check configuration file permissions

    // As it could contain sensitive data, we make it user-readable only.

    checkset_perm(def_filename, TRUE);

    scr_log_print(LPRINT_LOGNORM, "Reading %s", def_filename);

    g_free(def_filename);

  } else {

    // filename was specified

    if ((fp = fopen(filename, "r")) == NULL) {

      const char *msg = "Cannot open configuration file";

      if (mainfile)

        perror(msg);

      else

        scr_LogPrint(LPRINT_LOGNORM, "%s (%s).", msg, filename);

      err = -2;

      goto cfg_read_file_return;

    }

    // Check configuration file permissions (see above)

    // We don't change the permissions if that's not the main file.

    if (mainfile)

      checkset_perm(filename, TRUE);

    scr_LogPrint(LPRINT_LOGNORM, "Reading %s", filename);

  }

  buf = g_new(char, CONFLINE_LENGTH+1);

  while (fgets(buf+1, CONFLINE_LENGTH, fp) != NULL) {

    // The first char is reserved to add a '/', to make a command line

    line = buf+1;

    ln++;

    // Strip leading spaces

    while (isspace(*line))

      line++;

    // Make eol point to the last char of the line

    for (eol = line ; *eol ; eol++)

      ;

    if (eol > line)

      eol--;

    // Strip trailing spaces

    while (eol > line && isspace(*eol))

      *eol-- = 0;

    // Ignore empty lines and comments

    if ((*line == '\n') || (*line == '\0') || (*line == '#'))

      continue;

    // If we aren't in runtime (i.e. startup) we'll only accept "safe" commands

    if (!runtime) {

      const gchar *cmdend = strchr(line, ' ');

      gchar *cmdname = NULL;

      gboolean safe;

      if (cmdend)

        cmdname = g_strndup(line, cmdend - line);

      safe = cmd_is_safe(cmdname ? cmdname : line);

      g_free(cmdname);

      if (!safe) {

        scr_log_print(LPRINT_LOGNORM, "Error in configuration file (l. %d): "

                      "this command can't be used here", ln);

        err++;

        continue;

      }

    }

    // Set the leading COMMAND_CHAR to build a command line

    // and process the command

    *(--line) = COMMAND_CHAR;

    process_command(line, TRUE);

  }

  g_free(buf);

  fclose(fp);

  if (filename)

    scr_LogPrint(LPRINT_LOGNORM, "Loaded %s.", filename);

cfg_read_file_return:

  // If we're done with the main file parsing, we can assume that

  // the next time this function is called will be at run time.

  if (mainfile)

    runtime = TRUE;

  return err;

}

//  parse_assigment(assignment, pkey, pval)

// Read assignment and split it to key, value

//

// If this is an assignment, the function will return TRUE and

// set *pkey and *pval (*pval is set to NULL if value field is empty).

//

// If this isn't a assignment (no = char), the function will set *pval

// to NULL and return FALSE.

//

// The caller should g_free() *pkey and *pval (if not NULL) after use.

guint parse_assigment(gchar *assignment, gchar **pkey, gchar **pval)

{

  char *key, *val, *t, *p;

  *pkey = *pval = NULL;

  key = assignment;

  // Remove leading spaces in option name

  while ((!isalnum(*key)) && (*key != '=') && *key) {

    key++;

  }

  if (!*key) return FALSE; // Empty assignment

  if (*key == '=') {

    return FALSE;

  }

  // Ok, key points to the option name

  for (val = key+1 ; *val && (*val != '=') ; val++)

    if (!isalnum(*val) && !isblank(*val) && (*val != '_') && (*val != '-')) {

      // Key should only have alnum chars...

      return FALSE;

    }

  // Remove trailing spaces in option name:

  for (t = val-1 ; t > key && isblank(*t) ; t--)

    ;

  // Check for embedded whitespace characters

  for (p = key; p < t; p++) {

    if (isblank(*p)) {

      // Name should not contain space chars...

      return FALSE;

    }

  }

  *pkey = g_strndup(key, t+1-key);

  if (!*val) return FALSE; // Not an assignment

  // Remove leading and trailing spaces in option value:

  for (val++; *val && isblank(*val) ; val++) ;

  for (t = val ; *t ; t++) ;

  for (t-- ; t >= val && isblank(*t) ; t--) ;

  if (t < val) return TRUE; // no value (variable reset for example)

  // If the value begins and ends with quotes ("), these quotes are

  // removed and whitespace is not stripped

  if ((t>val) && (*val == '"' && *t == '"')) {

    val++;

    t--;

  }

  *pval = g_strndup(val, t+1-val);

  return TRUE;

}

gboolean settings_set_guard(const gchar *key, settings_guard_t guard)

{

  if (!guard)

    g_hash_table_remove(guards, key);

  else {

    installed_guard_t *iguard = g_hash_table_lookup(guards, key);

    if (iguard)

      return FALSE;

    iguard = g_new(installed_guard_t, 1);

    iguard->guard = guard;

    g_hash_table_insert(guards, g_strdup(key), iguard);

  }

  return TRUE;

}

void settings_del_guard(const gchar *key)

{

  settings_set_guard(key, NULL);

}

void settings_opt_set_raw(const gchar *key, const gchar *value)

{

  if (!value)

    g_hash_table_remove(option, key);

  else

    g_hash_table_insert(option, g_strdup(key), g_strdup(value));

}

void settings_set(guint type, const gchar *key, const gchar *value)

{

  GHashTable *hash;

  gchar *dup_value = NULL;

  installed_guard_t *guard = NULL;