/*

 * Copyright (C) the libgit2 contributors. All rights reserved.

 *

 * This file is part of libgit2, distributed under the GNU GPL v2 with

 * a Linking Exception. For full terms see the included COPYING file.

 */

#include "common.h"

#include "sysdir.h"

#include "config.h"

#include "git2/config.h"

#include "git2/sys/config.h"

#include "vector.h"

#include "buf_text.h"

#include "config_file.h"

#include "transaction.h"

#if GIT_WIN32

# include <windows.h>

#endif

#include <ctype.h>

void git_config_entry_free(git_config_entry *entry)

{

	if (!entry)

		return;

	entry->free(entry);

}

typedef struct {

	git_refcount rc;

	git_config_backend *file;

	git_config_level_t level;

} file_internal;

static void file_internal_free(file_internal *internal)

{

	git_config_backend *file;

	file = internal->file;

	file->free(file);

	git__free(internal);

}

static void config_free(git_config *cfg)

{

	size_t i;

	file_internal *internal;

	for (i = 0; i < cfg->files.length; ++i) {

		internal = git_vector_get(&cfg->files, i);

		GIT_REFCOUNT_DEC(internal, file_internal_free);

	}

	git_vector_free(&cfg->files);

	git__memzero(cfg, sizeof(*cfg));

	git__free(cfg);

}

void git_config_free(git_config *cfg)

{

	if (cfg == NULL)

		return;

	GIT_REFCOUNT_DEC(cfg, config_free);

}

static int config_backend_cmp(const void *a, const void *b)

{

	const file_internal *bk_a = (const file_internal *)(a);

	const file_internal *bk_b = (const file_internal *)(b);

	return bk_b->level - bk_a->level;

}

int git_config_new(git_config **out)

{

	git_config *cfg;

	cfg = git__malloc(sizeof(git_config));

	GITERR_CHECK_ALLOC(cfg);

	memset(cfg, 0x0, sizeof(git_config));

	if (git_vector_init(&cfg->files, 3, config_backend_cmp) < 0) {

		git__free(cfg);

		return -1;

	}

	*out = cfg;

	GIT_REFCOUNT_INC(cfg);

	return 0;

}

int git_config_add_file_ondisk(

	git_config *cfg,

	const char *path,

	git_config_level_t level,

	int force)

{

	git_config_backend *file = NULL;

	struct stat st;

	int res;

	assert(cfg && path);

	res = p_stat(path, &st);

	if (res < 0 && errno != ENOENT) {

		giterr_set(GITERR_CONFIG, "failed to stat '%s'", path);

		return -1;

	}

	if (git_config_file__ondisk(&file, path) < 0)

		return -1;

	if ((res = git_config_add_backend(cfg, file, level, force)) < 0) {

		/*

		 * free manually; the file is not owned by the config

		 * instance yet and will not be freed on cleanup

		 */

		file->free(file);

		return res;

	}

	return 0;

}

int git_config_open_ondisk(git_config **out, const char *path)

{

	int error;

	git_config *config;

	*out = NULL;

	if (git_config_new(&config) < 0)

		return -1;

	if ((error = git_config_add_file_ondisk(config, path, GIT_CONFIG_LEVEL_LOCAL, 0)) < 0)

		git_config_free(config);

	else

		*out = config;

	return error;

}

int git_config_snapshot(git_config **out, git_config *in)

{

	int error = 0;

	size_t i;

	file_internal *internal;

	git_config *config;

	*out = NULL;

	if (git_config_new(&config) < 0)

		return -1;

	git_vector_foreach(&in->files, i, internal) {

		git_config_backend *b;

		if ((error = internal->file->snapshot(&b, internal->file)) < 0)

			break;

		if ((error = git_config_add_backend(config, b, internal->level, 0)) < 0) {

			b->free(b);

			break;

		}

	}

	if (error < 0)

		git_config_free(config);

	else

		*out = config;

	return error;

}

static int find_internal_file_by_level(

	file_internal **internal_out,

	const git_config *cfg,

	git_config_level_t level)

{

	int pos = -1;

	file_internal *internal;

	size_t i;

	/* when passing GIT_CONFIG_HIGHEST_LEVEL, the idea is to get the config file

	 * which has the highest level. As config files are stored in a vector

	 * sorted by decreasing order of level, getting the file at position 0

	 * will do the job.

	 */

	if (level == GIT_CONFIG_HIGHEST_LEVEL) {

		pos = 0;

	} else {

		git_vector_foreach(&cfg->files, i, internal) {

			if (internal->level == level)

				pos = (int)i;

		}

	}

	if (pos == -1) {

		giterr_set(GITERR_CONFIG,

			"no config file exists for the given level '%i'", (int)level);

		return GIT_ENOTFOUND;

	}

	*internal_out = git_vector_get(&cfg->files, pos);

	return 0;

}

static int duplicate_level(void **old_raw, void *new_raw)

{

	file_internal **old = (file_internal **)old_raw;

	GIT_UNUSED(new_raw);

	giterr_set(GITERR_CONFIG, "a file with the same level (%i) has already been added to the config", (int)(*old)->level);

	return GIT_EEXISTS;

}

static void try_remove_existing_file_internal(

	git_config *cfg,

	git_config_level_t level)

{

	int pos = -1;

	file_internal *internal;

	size_t i;

	git_vector_foreach(&cfg->files, i, internal) {

		if (internal->level == level)

			pos = (int)i;

	}

	if (pos == -1)

		return;

	internal = git_vector_get(&cfg->files, pos);

	if (git_vector_remove(&cfg->files, pos) < 0)

		return;

	GIT_REFCOUNT_DEC(internal, file_internal_free);

}

static int git_config__add_internal(

	git_config *cfg,

	file_internal *internal,

	git_config_level_t level,

	int force)

{

	int result;

	/* delete existing config file for level if it exists */

	if (force)

		try_remove_existing_file_internal(cfg, level);

	if ((result = git_vector_insert_sorted(&cfg->files,

			internal, &duplicate_level)) < 0)

		return result;

	git_vector_sort(&cfg->files);

	internal->file->cfg = cfg;

	GIT_REFCOUNT_INC(internal);

	return 0;

}

int git_config_open_global(git_config **cfg_out, git_config *cfg)

{

	if (!git_config_open_level(cfg_out, cfg, GIT_CONFIG_LEVEL_XDG))

		return 0;

	return git_config_open_level(cfg_out, cfg, GIT_CONFIG_LEVEL_GLOBAL);

}

int git_config_open_level(

	git_config **cfg_out,

	const git_config *cfg_parent,

	git_config_level_t level)

{

	git_config *cfg;

	file_internal *internal;

	int res;

	if ((res = find_internal_file_by_level(&internal, cfg_parent, level)) < 0)

		return res;

	if ((res = git_config_new(&cfg)) < 0)

		return res;

	if ((res = git_config__add_internal(cfg, internal, level, true)) < 0) {

		git_config_free(cfg);

		return res;

	}

	*cfg_out = cfg;

	return 0;

}

int git_config_add_backend(

	git_config *cfg,

	git_config_backend *file,

	git_config_level_t level,

	int force)

{

	file_internal *internal;

	int result;

	assert(cfg && file);

	GITERR_CHECK_VERSION(file, GIT_CONFIG_BACKEND_VERSION, "git_config_backend");

	if ((result = file->open(file, level)) < 0)

		return result;

	internal = git__malloc(sizeof(file_internal));

	GITERR_CHECK_ALLOC(internal);

	memset(internal, 0x0, sizeof(file_internal));

	internal->file = file;

	internal->level = level;

	if ((result = git_config__add_internal(cfg, internal, level, force)) < 0) {

		git__free(internal);

		return result;

	}

	return 0;

}

/*

 * Loop over all the variables

 */

typedef struct {

	git_config_iterator parent;

	git_config_iterator *current;

	const git_config *cfg;

	regex_t regex;

	size_t i;

} all_iter;

static int find_next_backend(size_t *out, const git_config *cfg, size_t i)

{

	file_internal *internal;

	for (; i > 0; --i) {

		internal = git_vector_get(&cfg->files, i - 1);

		if (!internal || !internal->file)

			continue;

		*out = i;

		return 0;

	}

	return -1;

}

static int all_iter_next(git_config_entry **entry, git_config_iterator *_iter)

{

	all_iter *iter = (all_iter *) _iter;

	file_internal *internal;

	git_config_backend *backend;

	size_t i;

	int error = 0;

	if (iter->current != NULL &&

	    (error = iter->current->next(entry, iter->current)) == 0) {

		return 0;

	}

	if (error < 0 && error != GIT_ITEROVER)

		return error;

	do {

		if (find_next_backend(&i, iter->cfg, iter->i) < 0)

			return GIT_ITEROVER;

		internal = git_vector_get(&iter->cfg->files, i - 1);

		backend = internal->file;

		iter->i = i - 1;

		if (iter->current)

			iter->current->free(iter->current);

		iter->current = NULL;

		error = backend->iterator(&iter->current, backend);

		if (error == GIT_ENOTFOUND)

			continue;

		if (error < 0)

			return error;

		error = iter->current->next(entry, iter->current);

		/* If this backend is empty, then keep going */

		if (error == GIT_ITEROVER)

			continue;

		return error;

	} while(1);

	return GIT_ITEROVER;

}

static int all_iter_glob_next(git_config_entry **entry, git_config_iterator *_iter)

{

	int error;

	all_iter *iter = (all_iter *) _iter;

	/*

	 * We use the "normal" function to grab the next one across

	 * backends and then apply the regex

	 */

	while ((error = all_iter_next(entry, _iter)) == 0) {

		/* skip non-matching keys if regexp was provided */

		if (regexec(&iter->regex, (*entry)->name, 0, NULL, 0) != 0)

			continue;

		/* and simply return if we like the entry's name */

		return 0;

	}

	return error;

}

static void all_iter_free(git_config_iterator *_iter)

{

	all_iter *iter = (all_iter *) _iter;

	if (iter->current)

		iter->current->free(iter->current);

	git__free(iter);

}

static void all_iter_glob_free(git_config_iterator *_iter)

{

	all_iter *iter = (all_iter *) _iter;

	regfree(&iter->regex);

	all_iter_free(_iter);

}

int git_config_iterator_new(git_config_iterator **out, const git_config *cfg)

{

	all_iter *iter;

	iter = git__calloc(1, sizeof(all_iter));

	GITERR_CHECK_ALLOC(iter);

	iter->parent.free = all_iter_free;

	iter->parent.next = all_iter_next;

	iter->i = cfg->files.length;

	iter->cfg = cfg;

	*out = (git_config_iterator *) iter;

	return 0;

}

int git_config_iterator_glob_new(git_config_iterator **out, const git_config *cfg, const char *regexp)

{

	all_iter *iter;

	int result;

	if (regexp == NULL)

		return git_config_iterator_new(out, cfg);

	iter = git__calloc(1, sizeof(all_iter));

	GITERR_CHECK_ALLOC(iter);

	if ((result = p_regcomp(&iter->regex, regexp, REG_EXTENDED)) != 0) {

		giterr_set_regex(&iter->regex, result);

		git__free(iter);

		return -1;

	}

	iter->parent.next = all_iter_glob_next;

	iter->parent.free = all_iter_glob_free;

	iter->i = cfg->files.length;

	iter->cfg = cfg;

	*out = (git_config_iterator *) iter;

	return 0;

}

int git_config_foreach(

	const git_config *cfg, git_config_foreach_cb cb, void *payload)

{

	return git_config_foreach_match(cfg, NULL, cb, payload);

}

int git_config_backend_foreach_match(

	git_config_backend *backend,

	const char *regexp,

	git_config_foreach_cb cb,

	void *payload)

{

	git_config_entry *entry;

	git_config_iterator* iter;

	regex_t regex;

	int error = 0;

	if (regexp != NULL) {

		if ((error = p_regcomp(&regex, regexp, REG_EXTENDED)) != 0) {

			giterr_set_regex(&regex, error);

			regfree(&regex);

			return -1;

		}

	}

	if ((error = backend->iterator(&iter, backend)) < 0) {

		iter = NULL;

		return -1;

	}

	while (!(iter->next(&entry, iter) < 0)) {

		/* skip non-matching keys if regexp was provided */

		if (regexp && regexec(&regex, entry->name, 0, NULL, 0) != 0)

			continue;

		/* abort iterator on non-zero return value */

		if ((error = cb(entry, payload)) != 0) {

			giterr_set_after_callback(error);

			break;

		}

	}

	if (regexp != NULL)

		regfree(&regex);

	iter->free(iter);

	return error;

}

int git_config_foreach_match(

	const git_config *cfg,

	const char *regexp,

	git_config_foreach_cb cb,

	void *payload)

{

	int error;

	git_config_iterator *iter;

	git_config_entry *entry;

	if ((error = git_config_iterator_glob_new(&iter, cfg, regexp)) < 0)

		return error;

	while (!(error = git_config_next(&entry, iter))) {

		if ((error = cb(entry, payload)) != 0) {

			giterr_set_after_callback(error);

			break;

		}

	}

	git_config_iterator_free(iter);

	if (error == GIT_ITEROVER)

		error = 0;

	return error;

}

/**************

 * Setters

 **************/

typedef enum {

	BACKEND_USE_SET,

	BACKEND_USE_DELETE

} backend_use;

static const char *uses[] = {

    "set",

    "delete"

};

static int get_backend_for_use(git_config_backend **out,

	git_config *cfg, const char *name, backend_use use)

{

	size_t i;

	file_internal *f;

	*out = NULL;

	if (git_vector_length(&cfg->files) == 0) {

		giterr_set(GITERR_CONFIG,

			"cannot %s value for '%s' when no config files exist",

			uses[use], name);

		return GIT_ENOTFOUND;

	}

	git_vector_foreach(&cfg->files, i, f) {

		if (!f->file->readonly) {

			*out = f->file;

			return 0;

		}

	}

	giterr_set(GITERR_CONFIG,

		"cannot %s value for '%s' when all config files are readonly",

		uses[use], name);

	return GIT_ENOTFOUND;

}

int git_config_delete_entry(git_config *cfg, const char *name)

{

	git_config_backend *file;

	if (get_backend_for_use(&file, cfg, name, BACKEND_USE_DELETE) < 0)

		return GIT_ENOTFOUND;

	return file->del(file, name);

}

int git_config_set_int64(git_config *cfg, const char *name, int64_t value)

{

	char str_value[32]; /* All numbers should fit in here */

	p_snprintf(str_value, sizeof(str_value), "%" PRId64, value);

	return git_config_set_string(cfg, name, str_value);

}

int git_config_set_int32(git_config *cfg, const char *name, int32_t value)

{

	return git_config_set_int64(cfg, name, (int64_t)value);

}

int git_config_set_bool(git_config *cfg, const char *name, int value)

{

	return git_config_set_string(cfg, name, value ? "true" : "false");

}

int git_config_set_string(git_config *cfg, const char *name, const char *value)

{

	int error;

	git_config_backend *file;

	if (!value) {

		giterr_set(GITERR_CONFIG, "the value to set cannot be NULL");

		return -1;

	}

	if (get_backend_for_use(&file, cfg, name, BACKEND_USE_SET) < 0)

		return GIT_ENOTFOUND;

	error = file->set(file, name, value);

	if (!error && GIT_REFCOUNT_OWNER(cfg) != NULL)

		git_repository__cvar_cache_clear(GIT_REFCOUNT_OWNER(cfg));

	return error;

}

int git_config__update_entry(

	git_config *config,

	const char *key,

	const char *value,

	bool overwrite_existing,

	bool only_if_existing)

{

	int error = 0;

	git_config_entry *ce = NULL;

	if ((error = git_config__lookup_entry(&ce, config, key, false)) < 0)

		return error;

	if (!ce && only_if_existing) /* entry doesn't exist */

		return 0;

	if (ce && !overwrite_existing) /* entry would be overwritten */

		return 0;

	if (value && ce && ce->value && !strcmp(ce->value, value)) /* no change */

		return 0;

	if (!value && (!ce || !ce->value)) /* asked to delete absent entry */

		return 0;

	if (!value)

		error = git_config_delete_entry(config, key);

	else

		error = git_config_set_string(config, key, value);

	git_config_entry_free(ce);

	return error;

}

/***********

 * Getters

 ***********/

static int config_error_notfound(const char *name)

{

	giterr_set(GITERR_CONFIG, "config value '%s' was not found", name);

	return GIT_ENOTFOUND;

}

enum {

	GET_ALL_ERRORS = 0,

	GET_NO_MISSING = 1,

	GET_NO_ERRORS  = 2

};

static int get_entry(

	git_config_entry **out,

	const git_config *cfg,

	const char *name,

	bool normalize_name,

	int want_errors)

{

	int res = GIT_ENOTFOUND;

	const char *key = name;

	char *normalized = NULL;

	size_t i;

	file_internal *internal;

	*out = NULL;

	if (normalize_name) {

		if ((res = git_config__normalize_name(name, &normalized)) < 0)

			goto cleanup;

		key = normalized;

	}

	res = GIT_ENOTFOUND;

	git_vector_foreach(&cfg->files, i, internal) {

		if (!internal || !internal->file)

			continue;

		res = internal->file->get(internal->file, key, out);

		if (res != GIT_ENOTFOUND)

			break;

	}

	git__free(normalized);

cleanup:

	if (res == GIT_ENOTFOUND)

		res = (want_errors > GET_ALL_ERRORS) ? 0 : config_error_notfound(name);

	else if (res && (want_errors == GET_NO_ERRORS)) {

		giterr_clear();

		res = 0;

	}

	return res;

}

int git_config_get_entry(

	git_config_entry **out, const git_config *cfg, const char *name)

{

	return get_entry(out, cfg, name, true, GET_ALL_ERRORS);

}

int git_config__lookup_entry(

	git_config_entry **out,

	const git_config *cfg,

	const char *key,

	bool no_errors)

{

	return get_entry(

		out, cfg, key, false, no_errors ? GET_NO_ERRORS : GET_NO_MISSING);

}

int git_config_get_mapped(

	int *out,

	const git_config *cfg,

	const char *name,

	const git_cvar_map *maps,

	size_t map_n)

{

	git_config_entry *entry;

	int ret;

	if ((ret = get_entry(&entry, cfg, name, true, GET_ALL_ERRORS)) < 0)

		return ret;

	ret = git_config_lookup_map_value(out, maps, map_n, entry->value);

	git_config_entry_free(entry);

	return ret;

}

int git_config_get_int64(int64_t *out, const git_config *cfg, const char *name)

{

	git_config_entry *entry;

	int ret;

	if ((ret = get_entry(&entry, cfg, name, true, GET_ALL_ERRORS)) < 0)

		return ret;

	ret = git_config_parse_int64(out, entry->value);

	git_config_entry_free(entry);

	return ret;

}

int git_config_get_int32(int32_t *out, const git_config *cfg, const char *name)

{

	git_config_entry *entry;

	int ret;

	if ((ret = get_entry(&entry, cfg, name, true, GET_ALL_ERRORS)) < 0)

		return ret;

	ret = git_config_parse_int32(out, entry->value);

	git_config_entry_free(entry);

	return ret;

}

int git_config_get_bool(int *out, const git_config *cfg, const char *name)

{

	git_config_entry *entry;

	int ret;

	if ((ret = get_entry(&entry, cfg, name, true, GET_ALL_ERRORS)) < 0)

		return ret;

	ret = git_config_parse_bool(out, entry->value);

	git_config_entry_free(entry);

	return ret;

}

static int is_readonly(const git_config *cfg)

{

	size_t i;

	file_internal *internal;

	git_vector_foreach(&cfg->files, i, internal) {

		if (!internal || !internal->file)

			continue;

		if (!internal->file->readonly)

			return 0;

	}

	return 1;

}

int git_config_get_path(git_buf *out, const git_config *cfg, const char *name)

{

	git_config_entry *entry;

	int error;

	if ((error = get_entry(&entry, cfg, name, true, GET_ALL_ERRORS)) < 0)

		return error;

	 error = git_config_parse_path(out, entry->value);

	 git_config_entry_free(entry);

	 return error;

}

int git_config_get_string(

	const char **out, const git_config *cfg, const char *name)

{

	git_config_entry *entry;

	int ret;

	if (!is_readonly(cfg)) {

		giterr_set(GITERR_CONFIG, "get_string called on a live config object");

		return -1;

	}

	ret = get_entry(&entry, cfg, name, true, GET_ALL_ERRORS);

	*out = !ret ? (entry->value ? entry->value : "") : NULL;

	git_config_entry_free(entry);

	return ret;

}