rugged 0.27.10 → 0.27.10.1

data/vendor/libgit2/src/config.h

@@ -24,7 +24,7 @@
 
 struct git_config {
 	git_refcount rc;
-	git_vector backends;
+	git_vector files;
 };
 
 extern int git_config__global_location(git_buf *buf);
@@ -34,6 +34,19 @@ extern int git_config_rename_section(
 	const char *old_section_name,	/* eg "branch.dummy" */
 	const char *new_section_name);	/* NULL to drop the old section */
 
+/**
+ * Create a configuration file backend for ondisk files
+ *
+ * These are the normal `.gitconfig` files that Core Git
+ * processes. Note that you first have to add this file to a
+ * configuration object before you can query it for configuration
+ * variables.
+ *
+ * @param out the new backend
+ * @param path where the config file is located
+ */
+extern int git_config_file__ondisk(git_config_backend **out, const char *path);
+
 extern int git_config__normalize_name(const char *in, char **out);
 
 /* internal only: does not normalize key and sets out to NULL if not found */
@@ -66,19 +79,18 @@ extern int git_config__get_bool_force(
 extern int git_config__get_int_force(
 	const git_config *cfg, const char *key, int fallback_value);
 
-/* API for repository configmap-style lookups from config - not cached, but
- * uses configmap value maps and fallbacks
+/* API for repository cvar-style lookups from config - not cached, but
+ * uses cvar value maps and fallbacks
  */
-extern int git_config__configmap_lookup(
-	int *out, git_config *config, git_configmap_item item);
+extern int git_config__cvar(
+	int *out, git_config *config, git_cvar_cached cvar);
 
 /**
  * The opposite of git_config_lookup_map_value, we take an enum value
  * and map it to the string or bool value on the config.
  */
-int git_config_lookup_map_enum(git_configmap_t *type_out,
-	const char **str_out, const git_configmap *maps,
-	size_t map_n, int enum_val);
+int git_config_lookup_map_enum(git_cvar_t *type_out, const char **str_out,
+			       const git_cvar_map *maps, size_t map_n, int enum_val);
 
 /**
  * Unlock the backend with the highest priority

data/vendor/libgit2/src/config_cache.c

@@ -7,7 +7,7 @@
 
 #include "common.h"
 
-#include "futils.h"
+#include "fileops.h"
 #include "repository.h"
 #include "config.h"
 #include "git2/config.h"
@@ -15,8 +15,8 @@
 #include "filter.h"
 
 struct map_data {
-	const char *name;
-	git_configmap *maps;
+	const char *cvar_name;
+	git_cvar_map *maps;
 	size_t map_count;
 	int default_value;
 };
@@ -29,11 +29,11 @@ struct map_data {
  *	value is native. See gitattributes(5) for more information on
  *	end-of-line conversion.
  */
-static git_configmap _configmap_eol[] = {
-	{GIT_CONFIGMAP_FALSE, NULL, GIT_EOL_UNSET},
-	{GIT_CONFIGMAP_STRING, "lf", GIT_EOL_LF},
-	{GIT_CONFIGMAP_STRING, "crlf", GIT_EOL_CRLF},
-	{GIT_CONFIGMAP_STRING, "native", GIT_EOL_NATIVE}
+static git_cvar_map _cvar_map_eol[] = {
+	{GIT_CVAR_FALSE, NULL, GIT_EOL_UNSET},
+	{GIT_CVAR_STRING, "lf", GIT_EOL_LF},
+	{GIT_CVAR_STRING, "crlf", GIT_EOL_CRLF},
+	{GIT_CVAR_STRING, "native", GIT_EOL_NATIVE}
 };
 
 /*
@@ -46,55 +46,49 @@ static git_configmap _configmap_eol[] = {
  *	does not have normalized line endings. This variable can be set to input,
  *	in which case no output conversion is performed.
  */
-static git_configmap _configmap_autocrlf[] = {
-	{GIT_CONFIGMAP_FALSE, NULL, GIT_AUTO_CRLF_FALSE},
-	{GIT_CONFIGMAP_TRUE, NULL, GIT_AUTO_CRLF_TRUE},
-	{GIT_CONFIGMAP_STRING, "input", GIT_AUTO_CRLF_INPUT}
+static git_cvar_map _cvar_map_autocrlf[] = {
+	{GIT_CVAR_FALSE, NULL, GIT_AUTO_CRLF_FALSE},
+	{GIT_CVAR_TRUE, NULL, GIT_AUTO_CRLF_TRUE},
+	{GIT_CVAR_STRING, "input", GIT_AUTO_CRLF_INPUT}
 };
 
-static git_configmap _configmap_safecrlf[] = {
-	{GIT_CONFIGMAP_FALSE, NULL, GIT_SAFE_CRLF_FALSE},
-	{GIT_CONFIGMAP_TRUE, NULL, GIT_SAFE_CRLF_FAIL},
-	{GIT_CONFIGMAP_STRING, "warn", GIT_SAFE_CRLF_WARN}
-};
-
-static git_configmap _configmap_logallrefupdates[] = {
-	{GIT_CONFIGMAP_FALSE, NULL, GIT_LOGALLREFUPDATES_FALSE},
-	{GIT_CONFIGMAP_TRUE, NULL, GIT_LOGALLREFUPDATES_TRUE},
-	{GIT_CONFIGMAP_STRING, "always", GIT_LOGALLREFUPDATES_ALWAYS},
+static git_cvar_map _cvar_map_safecrlf[] = {
+	{GIT_CVAR_FALSE, NULL, GIT_SAFE_CRLF_FALSE},
+	{GIT_CVAR_TRUE, NULL, GIT_SAFE_CRLF_FAIL},
+	{GIT_CVAR_STRING, "warn", GIT_SAFE_CRLF_WARN}
 };
 
 /*
  * Generic map for integer values
  */
-static git_configmap _configmap_int[] = {
-	{GIT_CONFIGMAP_INT32, NULL, 0},
+static git_cvar_map _cvar_map_int[] = {
+	{GIT_CVAR_INT32, NULL, 0},
 };
 
-static struct map_data _configmaps[] = {
-	{"core.autocrlf", _configmap_autocrlf, ARRAY_SIZE(_configmap_autocrlf), GIT_AUTO_CRLF_DEFAULT},
-	{"core.eol", _configmap_eol, ARRAY_SIZE(_configmap_eol), GIT_EOL_DEFAULT},
+static struct map_data _cvar_maps[] = {
+	{"core.autocrlf", _cvar_map_autocrlf, ARRAY_SIZE(_cvar_map_autocrlf), GIT_AUTO_CRLF_DEFAULT},
+	{"core.eol", _cvar_map_eol, ARRAY_SIZE(_cvar_map_eol), GIT_EOL_DEFAULT},
 	{"core.symlinks", NULL, 0, GIT_SYMLINKS_DEFAULT },
 	{"core.ignorecase", NULL, 0, GIT_IGNORECASE_DEFAULT },
 	{"core.filemode", NULL, 0, GIT_FILEMODE_DEFAULT },
 	{"core.ignorestat", NULL, 0, GIT_IGNORESTAT_DEFAULT },
 	{"core.trustctime", NULL, 0, GIT_TRUSTCTIME_DEFAULT },
-	{"core.abbrev", _configmap_int, 1, GIT_ABBREV_DEFAULT },
+	{"core.abbrev", _cvar_map_int, 1, GIT_ABBREV_DEFAULT },
 	{"core.precomposeunicode", NULL, 0, GIT_PRECOMPOSE_DEFAULT },
-	{"core.safecrlf", _configmap_safecrlf, ARRAY_SIZE(_configmap_safecrlf), GIT_SAFE_CRLF_DEFAULT},
-	{"core.logallrefupdates", _configmap_logallrefupdates, ARRAY_SIZE(_configmap_logallrefupdates), GIT_LOGALLREFUPDATES_DEFAULT},
+	{"core.safecrlf", _cvar_map_safecrlf, ARRAY_SIZE(_cvar_map_safecrlf), GIT_SAFE_CRLF_DEFAULT},
+	{"core.logallrefupdates", NULL, 0, GIT_LOGALLREFUPDATES_DEFAULT },
 	{"core.protecthfs", NULL, 0, GIT_PROTECTHFS_DEFAULT },
 	{"core.protectntfs", NULL, 0, GIT_PROTECTNTFS_DEFAULT },
 	{"core.fsyncobjectfiles", NULL, 0, GIT_FSYNCOBJECTFILES_DEFAULT },
 };
 
-int git_config__configmap_lookup(int *out, git_config *config, git_configmap_item item)
+int git_config__cvar(int *out, git_config *config, git_cvar_cached cvar)
 {
 	int error = 0;
-	struct map_data *data = &_configmaps[(int)item];
+	struct map_data *data = &_cvar_maps[(int)cvar];
 	git_config_entry *entry;
 
-	if ((error = git_config__lookup_entry(&entry, config, data->name, false)) < 0)
+	if ((error = git_config__lookup_entry(&entry, config, data->cvar_name, false)) < 0)
 		return error;
 
 	if (!entry)
@@ -109,29 +103,29 @@ int git_config__configmap_lookup(int *out, git_config *config, git_configmap_ite
 	return error;
 }
 
-int git_repository__configmap_lookup(int *out, git_repository *repo, git_configmap_item item)
+int git_repository__cvar(int *out, git_repository *repo, git_cvar_cached cvar)
 {
-	*out = repo->configmap_cache[(int)item];
+	*out = repo->cvar_cache[(int)cvar];
 
-	if (*out == GIT_CONFIGMAP_NOT_CACHED) {
+	if (*out == GIT_CVAR_NOT_CACHED) {
 		int error;
 		git_config *config;
 
 		if ((error = git_repository_config__weakptr(&config, repo)) < 0 ||
-			(error = git_config__configmap_lookup(out, config, item)) < 0)
+			(error = git_config__cvar(out, config, cvar)) < 0)
 			return error;
 
-		repo->configmap_cache[(int)item] = *out;
+		repo->cvar_cache[(int)cvar] = *out;
 	}
 
 	return 0;
 }
 
-void git_repository__configmap_lookup_cache_clear(git_repository *repo)
+void git_repository__cvar_cache_clear(git_repository *repo)
 {
 	int i;
 
-	for (i = 0; i < GIT_CONFIGMAP_CACHE_MAX; ++i)
-		repo->configmap_cache[i] = GIT_CONFIGMAP_NOT_CACHED;
+	for (i = 0; i < GIT_CVAR_CACHE_MAX; ++i)
+		repo->cvar_cache[i] = GIT_CVAR_NOT_CACHED;
 }
 

data/vendor/libgit2/src/config_file.c

@@ -5,37 +5,93 @@
  * a Linking Exception. For full terms see the included COPYING file.
  */
 
-#include "config.h"
+#include "config_file.h"
 
+#include "config.h"
+#include "filebuf.h"
+#include "sysdir.h"
+#include "buffer.h"
+#include "buf_text.h"
 #include "git2/config.h"
 #include "git2/sys/config.h"
-
+#include "git2/types.h"
+#include "strmap.h"
 #include "array.h"
-#include "buffer.h"
-#include "config_backend.h"
-#include "config_entries.h"
 #include "config_parse.h"
-#include "filebuf.h"
-#include "regexp.h"
-#include "sysdir.h"
-#include "wildmatch.h"
+
+#include <ctype.h>
+#include <sys/types.h>
+#include <regex.h>
+
+typedef struct cvar_t {
+	struct cvar_t *next;
+	git_config_entry *entry;
+	bool included; /* whether this is part of [include] */
+} cvar_t;
+
+typedef struct git_config_file_iter {
+	git_config_iterator parent;
+	git_strmap_iter iter;
+	cvar_t* next_var;
+} git_config_file_iter;
 
 /* Max depth for [include] directives */
 #define MAX_INCLUDE_DEPTH 10
 
-typedef struct config_file {
-	git_futils_filestamp stamp;
-	git_oid checksum;
-	char *path;
-	git_array_t(struct config_file) includes;
-} config_file;
+#define CVAR_LIST_HEAD(list) ((list)->head)
+
+#define CVAR_LIST_TAIL(list) ((list)->tail)
+
+#define CVAR_LIST_NEXT(var) ((var)->next)
+
+#define CVAR_LIST_EMPTY(list) ((list)->head == NULL)
+
+#define CVAR_LIST_APPEND(list, var) do {\
+	if (CVAR_LIST_EMPTY(list)) {\
+		CVAR_LIST_HEAD(list) = CVAR_LIST_TAIL(list) = var;\
+	} else {\
+		CVAR_LIST_NEXT(CVAR_LIST_TAIL(list)) = var;\
+		CVAR_LIST_TAIL(list) = var;\
+	}\
+} while(0)
+
+#define CVAR_LIST_REMOVE_HEAD(list) do {\
+	CVAR_LIST_HEAD(list) = CVAR_LIST_NEXT(CVAR_LIST_HEAD(list));\
+} while(0)
+
+#define CVAR_LIST_REMOVE_AFTER(var) do {\
+	CVAR_LIST_NEXT(var) = CVAR_LIST_NEXT(CVAR_LIST_NEXT(var));\
+} while(0)
+
+#define CVAR_LIST_FOREACH(list, iter)\
+	for ((iter) = CVAR_LIST_HEAD(list);\
+		 (iter) != NULL;\
+		 (iter) = CVAR_LIST_NEXT(iter))
+
+/*
+ * Inspired by the FreeBSD functions
+ */
+#define CVAR_LIST_FOREACH_SAFE(start, iter, tmp)\
+	for ((iter) = CVAR_LIST_HEAD(vars);\
+		 (iter) && (((tmp) = CVAR_LIST_NEXT(iter) || 1));\
+		 (iter) = (tmp))
+
+typedef struct {
+	git_atomic refcount;
+	git_strmap *values;
+} refcounted_strmap;
 
 typedef struct {
 	git_config_backend parent;
+	/* mutex to coordinate accessing the values */
 	git_mutex values_mutex;
-	git_config_entries *entries;
+	refcounted_strmap *values;
 	const git_repository *repo;
 	git_config_level_t level;
+} diskfile_header;
+
+typedef struct {
+	diskfile_header header;
 
 	git_array_t(git_config_parser) readers;
 
@@ -43,47 +99,158 @@ typedef struct {
 	git_filebuf locked_buf;
 	git_buf locked_content;
 
-	config_file file;
-} config_file_backend;
+	struct config_file file;
+} diskfile_backend;
 
 typedef struct {
-	const git_repository *repo;
-	config_file *file;
-	git_config_entries *entries;
-	git_config_level_t level;
-	unsigned int depth;
-} config_file_parse_data;
+	diskfile_header header;
+
+	diskfile_backend *snapshot_from;
+} diskfile_readonly_backend;
 
-static int config_file_read(git_config_entries *entries, const git_repository *repo, config_file *file, git_config_level_t level, int depth);
-static int config_file_read_buffer(git_config_entries *entries, const git_repository *repo, config_file *file, git_config_level_t level, int depth, const char *buf, size_t buflen);
-static int config_file_write(config_file_backend *cfg, const char *orig_key, const char *key, const git_regexp *preg, const char *value);
+static int config_read(git_strmap *values, const git_repository *repo, git_config_file *file, git_config_level_t level, int depth);
+static int config_write(diskfile_backend *cfg, const char *orig_key, const char *key, const regex_t *preg, const char *value);
 static char *escape_value(const char *ptr);
 
+int git_config_file__snapshot(git_config_backend **out, diskfile_backend *in);
+static int config_snapshot(git_config_backend **out, git_config_backend *in);
+
+static int config_error_readonly(void)
+{
+	giterr_set(GITERR_CONFIG, "this backend is read-only");
+	return -1;
+}
+
+static void cvar_free(cvar_t *var)
+{
+	if (var == NULL)
+		return;
+
+	git__free((char*)var->entry->name);
+	git__free((char *)var->entry->value);
+	git__free(var->entry);
+	git__free(var);
+}
+
+int git_config_file_normalize_section(char *start, char *end)
+{
+	char *scan;
+
+	if (start == end)
+		return GIT_EINVALIDSPEC;
+
+	/* Validate and downcase range */
+	for (scan = start; *scan; ++scan) {
+		if (end && scan >= end)
+			break;
+		if (isalnum(*scan))
+			*scan = (char)git__tolower(*scan);
+		else if (*scan != '-' || scan == start)
+			return GIT_EINVALIDSPEC;
+	}
+
+	if (scan == start)
+		return GIT_EINVALIDSPEC;
+
+	return 0;
+}
+
+/* Add or append the new config option */
+static int append_entry(git_strmap *values, cvar_t *var)
+{
+	git_strmap_iter pos;
+	cvar_t *existing;
+	int error = 0;
+
+	pos = git_strmap_lookup_index(values, var->entry->name);
+	if (!git_strmap_valid_index(values, pos)) {
+		git_strmap_insert(values, var->entry->name, var, &error);
+	} else {
+		existing = git_strmap_value_at(values, pos);
+		while (existing->next != NULL) {
+			existing = existing->next;
+		}
+		existing->next = var;
+	}
+
+	if (error > 0)
+		error = 0;
+
+	return error;
+}
+
+static void free_vars(git_strmap *values)
+{
+	cvar_t *var = NULL;
+
+	if (values == NULL)
+		return;
+
+	git_strmap_foreach_value(values, var,
+		while (var != NULL) {
+			cvar_t *next = CVAR_LIST_NEXT(var);
+			cvar_free(var);
+			var = next;
+		});
+
+	git_strmap_free(values);
+}
+
+static void refcounted_strmap_free(refcounted_strmap *map)
+{
+	if (!map)
+		return;
+
+	if (git_atomic_dec(&map->refcount) != 0)
+		return;
+
+	free_vars(map->values);
+	git__free(map);
+}
+
 /**
  * Take the current values map from the backend and increase its
  * refcount. This is its own function to make sure we use the mutex to
  * avoid the map pointer from changing under us.
  */
-static int config_file_entries_take(git_config_entries **out, config_file_backend *b)
+static refcounted_strmap *refcounted_strmap_take(diskfile_header *h)
 {
-	int error;
+	refcounted_strmap *map;
 
-	if ((error = git_mutex_lock(&b->values_mutex)) < 0) {
-		git_error_set(GIT_ERROR_OS, "failed to lock config backend");
-		return error;
+	if (git_mutex_lock(&h->values_mutex) < 0) {
+	    giterr_set(GITERR_OS, "failed to lock config backend");
+	    return NULL;
 	}
 
-	git_config_entries_incref(b->entries);
-	*out = b->entries;
+	map = h->values;
+	git_atomic_inc(&map->refcount);
 
-	git_mutex_unlock(&b->values_mutex);
+	git_mutex_unlock(&h->values_mutex);
 
-	return 0;
+	return map;
 }
 
-static void config_file_clear(config_file *file)
+static int refcounted_strmap_alloc(refcounted_strmap **out)
 {
-	config_file *include;
+	refcounted_strmap *map;
+	int error;
+
+	map = git__calloc(1, sizeof(refcounted_strmap));
+	GITERR_CHECK_ALLOC(map);
+
+	git_atomic_set(&map->refcount, 1);
+
+	if ((error = git_strmap_alloc(&map->values)) < 0)
+		git__free(map);
+	else
+		*out = map;
+
+	return error;
+}
+
+static void config_file_clear(struct config_file *file)
+{
+	struct config_file *include;
 	uint32_t i;
 
 	if (file == NULL)
@@ -97,31 +264,31 @@ static void config_file_clear(config_file *file)
 	git__free(file->path);
 }
 
-static int config_file_open(git_config_backend *cfg, git_config_level_t level, const git_repository *repo)
+static int config_open(git_config_backend *cfg, git_config_level_t level, const git_repository *repo)
 {
-	config_file_backend *b = GIT_CONTAINER_OF(cfg, config_file_backend, parent);
 	int res;
+	diskfile_backend *b = (diskfile_backend *)cfg;
 
-	b->level = level;
-	b->repo = repo;
+	b->header.level = level;
+	b->header.repo = repo;
 
-	if ((res = git_config_entries_new(&b->entries)) < 0)
+	if ((res = refcounted_strmap_alloc(&b->header.values)) < 0)
 		return res;
 
 	if (!git_path_exists(b->file.path))
 		return 0;
 
-	if (res < 0 || (res = config_file_read(b->entries, repo, &b->file, level, 0)) < 0) {
-		git_config_entries_free(b->entries);
-		b->entries = NULL;
+	if (res < 0 || (res = config_read(b->header.values->values, repo, &b->file, level, 0)) < 0) {
+		refcounted_strmap_free(b->header.values);
+		b->header.values = NULL;
 	}
 
 	return res;
 }
 
-static int config_file_is_modified(int *modified, config_file *file)
+static int config_is_modified(int *modified, struct config_file *file)
 {
-	config_file *include;
+	git_config_file *include;
 	git_buf buf = GIT_BUF_INIT;
 	git_oid hash;
 	uint32_t i;
@@ -129,9 +296,6 @@ static int config_file_is_modified(int *modified, config_file *file)
 
 	*modified = 0;
 
-	if (!git_futils_filestamp_check(&file->stamp, file->path))
-		goto check_includes;
-
 	if ((error = git_futils_readbuffer(&buf, file->path)) < 0)
 		goto out;
 
@@ -143,305 +307,388 @@ static int config_file_is_modified(int *modified, config_file *file)
 		goto out;
 	}
 
-check_includes:
 	git_array_foreach(file->includes, i, include) {
-		if ((error = config_file_is_modified(modified, include)) < 0 || *modified)
+		if ((error = config_is_modified(modified, include)) < 0 || *modified)
 			goto out;
 	}
 
 out:
-	git_buf_dispose(&buf);
+	git_buf_free(&buf);
 
 	return error;
 }
 
-static int config_file_set_entries(git_config_backend *cfg, git_config_entries *entries)
+static int config_refresh(git_config_backend *cfg)
 {
-	config_file_backend *b = GIT_CONTAINER_OF(cfg, config_file_backend, parent);
-	git_config_entries *old = NULL;
-	config_file *include;
-	int error;
+	diskfile_backend *b = (diskfile_backend *)cfg;
+	refcounted_strmap *values = NULL, *tmp;
+	git_config_file *include;
+	int error, modified;
 	uint32_t i;
 
-	if (b->parent.readonly) {
-		git_error_set(GIT_ERROR_CONFIG, "this backend is read-only");
-		return -1;
-	}
+	if (b->header.parent.readonly)
+		return config_error_readonly();
 
-	git_array_foreach(b->file.includes, i, include)
-		config_file_clear(include);
-	git_array_clear(b->file.includes);
-
-	if ((error = git_mutex_lock(&b->values_mutex)) < 0) {
-		git_error_set(GIT_ERROR_OS, "failed to lock config backend");
+	error = config_is_modified(&modified, &b->file);
+	if (error < 0 && error != GIT_ENOTFOUND)
 		goto out;
-	}
-
-	old = b->entries;
-	b->entries = entries;
-
-	git_mutex_unlock(&b->values_mutex);
-
-out:
-	git_config_entries_free(old);
-	return error;
-}
 
-static int config_file_refresh_from_buffer(git_config_backend *cfg, const char *buf, size_t buflen)
-{
-	config_file_backend *b = GIT_CONTAINER_OF(cfg, config_file_backend, parent);
-	git_config_entries *entries = NULL;
-	int error;
+	if (!modified)
+		return 0;
 
-	if ((error = git_config_entries_new(&entries)) < 0 ||
-	    (error = config_file_read_buffer(entries, b->repo, &b->file,
-					     b->level, 0, buf, buflen)) < 0 ||
-	    (error = config_file_set_entries(cfg, entries)) < 0)
+	if ((error = refcounted_strmap_alloc(&values)) < 0)
 		goto out;
 
-	entries = NULL;
-out:
-	git_config_entries_free(entries);
-	return error;
-}
-
-static int config_file_refresh(git_config_backend *cfg)
-{
-	config_file_backend *b = GIT_CONTAINER_OF(cfg, config_file_backend, parent);
-	git_config_entries *entries = NULL;
-	int error, modified;
+	/* Reparse the current configuration */
+	git_array_foreach(b->file.includes, i, include) {
+		config_file_clear(include);
+	}
+	git_array_clear(b->file.includes);
 
-	if (cfg->readonly)
-		return 0;
+	if ((error = config_read(values->values, b->header.repo, &b->file, b->header.level, 0)) < 0)
+		goto out;
 
-	if ((error = config_file_is_modified(&modified, &b->file)) < 0 && error != GIT_ENOTFOUND)
+	if ((error = git_mutex_lock(&b->header.values_mutex)) < 0) {
+		giterr_set(GITERR_OS, "failed to lock config backend");
 		goto out;
+	}
 
-	if (!modified)
-		return 0;
+	tmp = b->header.values;
+	b->header.values = values;
+	values = tmp;
 
-	if ((error = git_config_entries_new(&entries)) < 0 ||
-	    (error = config_file_read(entries, b->repo, &b->file, b->level, 0)) < 0 ||
-	    (error = config_file_set_entries(cfg, entries)) < 0)
-		goto out;
+	git_mutex_unlock(&b->header.values_mutex);
 
-	entries = NULL;
 out:
-	git_config_entries_free(entries);
+	refcounted_strmap_free(values);
 
 	return (error == GIT_ENOTFOUND) ? 0 : error;
 }
 
-static void config_file_free(git_config_backend *_backend)
+static void backend_free(git_config_backend *_backend)
 {
-	config_file_backend *backend = GIT_CONTAINER_OF(_backend, config_file_backend, parent);
+	diskfile_backend *backend = (diskfile_backend *)_backend;
 
 	if (backend == NULL)
 		return;
 
 	config_file_clear(&backend->file);
-	git_config_entries_free(backend->entries);
-	git_mutex_free(&backend->values_mutex);
+	refcounted_strmap_free(backend->header.values);
+	git_mutex_free(&backend->header.values_mutex);
 	git__free(backend);
 }
 
-static int config_file_iterator(
-	git_config_iterator **iter,
-	struct git_config_backend *backend)
+static void config_iterator_free(
+	git_config_iterator* iter)
 {
-	config_file_backend *b = GIT_CONTAINER_OF(backend, config_file_backend, parent);
-	git_config_entries *dupped = NULL, *entries = NULL;
-	int error;
-
-	if ((error = config_file_refresh(backend)) < 0 ||
-	    (error = config_file_entries_take(&entries, b)) < 0 ||
-	    (error = git_config_entries_dup(&dupped, entries)) < 0 ||
-	    (error = git_config_entries_iterator_new(iter, dupped)) < 0)
-		goto out;
-
-out:
-	/* Let iterator delete duplicated entries when it's done */
-	git_config_entries_free(entries);
-	git_config_entries_free(dupped);
-	return error;
+	iter->backend->free(iter->backend);
+	git__free(iter);
 }
 
-static int config_file_snapshot(git_config_backend **out, git_config_backend *backend)
+static int config_iterator_next(
+	git_config_entry **entry,
+	git_config_iterator *iter)
 {
-	return git_config_backend_snapshot(out, backend);
+	git_config_file_iter *it = (git_config_file_iter *) iter;
+	diskfile_header *h = (diskfile_header *) it->parent.backend;
+	git_strmap *values = h->values->values;
+	int err = 0;
+	cvar_t * var;
+
+	if (it->next_var == NULL) {
+		err = git_strmap_next((void**) &var, &(it->iter), values);
+	} else {
+		var = it->next_var;
+	}
+
+	if (err < 0) {
+		it->next_var = NULL;
+		return err;
+	}
+
+	*entry = var->entry;
+	it->next_var = CVAR_LIST_NEXT(var);
+
+	return 0;
 }
 
-static int config_file_set(git_config_backend *cfg, const char *name, const char *value)
+static int config_iterator_new(
+	git_config_iterator **iter,
+	struct git_config_backend* backend)
 {
-	config_file_backend *b = GIT_CONTAINER_OF(cfg, config_file_backend, parent);
-	git_config_entries *entries;
-	git_config_entry *existing;
-	char *key, *esc_value = NULL;
+	diskfile_header *h;
+	git_config_file_iter *it;
+	git_config_backend *snapshot;
+	diskfile_header *bh = (diskfile_header *) backend;
 	int error;
 
-	if ((error = git_config__normalize_name(name, &key)) < 0)
+	if ((error = config_snapshot(&snapshot, backend)) < 0)
 		return error;
 
-	if ((error = config_file_entries_take(&entries, b)) < 0)
+	if ((error = snapshot->open(snapshot, bh->level, bh->repo)) < 0)
 		return error;
 
-	/* Check whether we'd be modifying an included or multivar key */
-	if ((error = git_config_entries_get_unique(&existing, entries, key)) < 0) {
-		if (error != GIT_ENOTFOUND)
+	it = git__calloc(1, sizeof(git_config_file_iter));
+	GITERR_CHECK_ALLOC(it);
+
+	h = (diskfile_header *)snapshot;
+
+	/* strmap_begin() is currently a macro returning 0 */
+	GIT_UNUSED(h);
+
+	it->parent.backend = snapshot;
+	it->iter = git_strmap_begin(h->values);
+	it->next_var = NULL;
+
+	it->parent.next = config_iterator_next;
+	it->parent.free = config_iterator_free;
+	*iter = (git_config_iterator *) it;
+
+	return 0;
+}
+
+static int config_set(git_config_backend *cfg, const char *name, const char *value)
+{
+	diskfile_backend *b = (diskfile_backend *)cfg;
+	refcounted_strmap *map;
+	git_strmap *values;
+	char *key, *esc_value = NULL;
+	khiter_t pos;
+	int rval, ret;
+
+	if ((rval = git_config__normalize_name(name, &key)) < 0)
+		return rval;
+
+	if ((map = refcounted_strmap_take(&b->header)) == NULL)
+		return -1;
+	values = map->values;
+
+	/*
+	 * Try to find it in the existing values and update it if it
+	 * only has one value.
+	 */
+	pos = git_strmap_lookup_index(values, key);
+	if (git_strmap_valid_index(values, pos)) {
+		cvar_t *existing = git_strmap_value_at(values, pos);
+
+		if (existing->next != NULL) {
+			giterr_set(GITERR_CONFIG, "multivar incompatible with simple set");
+			ret = -1;
 			goto out;
-		error = 0;
-	} else if ((!existing->value && !value) ||
-		   (existing->value && value && !strcmp(existing->value, value))) {
+		}
+
+		if (existing->included) {
+			giterr_set(GITERR_CONFIG, "modifying included variable is not supported");
+			ret = -1;
+			goto out;
+		}
+
 		/* don't update if old and new values already match */
-		error = 0;
-		goto out;
+		if ((!existing->entry->value && !value) ||
+			(existing->entry->value && value &&
+			 !strcmp(existing->entry->value, value))) {
+			ret = 0;
+			goto out;
+		}
 	}
 
 	/* No early returns due to sanity checks, let's write it out and refresh */
+
 	if (value) {
 		esc_value = escape_value(value);
-		GIT_ERROR_CHECK_ALLOC(esc_value);
+		GITERR_CHECK_ALLOC(esc_value);
 	}
 
-	if ((error = config_file_write(b, name, key, NULL, esc_value)) < 0)
+	if ((ret = config_write(b, name, key, NULL, esc_value)) < 0)
 		goto out;
 
+	ret = config_refresh(cfg);
+
 out:
-	git_config_entries_free(entries);
+	refcounted_strmap_free(map);
 	git__free(esc_value);
 	git__free(key);
-	return error;
+	return ret;
 }
 
 /* release the map containing the entry as an equivalent to freeing it */
-static void config_file_entry_free(git_config_entry *entry)
+static void release_map(git_config_entry *entry)
 {
-	git_config_entries *entries = (git_config_entries *) entry->payload;
-	git_config_entries_free(entries);
+	refcounted_strmap *map = (refcounted_strmap *) entry->payload;
+	refcounted_strmap_free(map);
 }
 
 /*
  * Internal function that actually gets the value in string form
  */
-static int config_file_get(git_config_backend *cfg, const char *key, git_config_entry **out)
+static int config_get(git_config_backend *cfg, const char *key, git_config_entry **out)
 {
-	config_file_backend *h = GIT_CONTAINER_OF(cfg, config_file_backend, parent);
-	git_config_entries *entries = NULL;
-	git_config_entry *entry;
+	diskfile_header *h = (diskfile_header *)cfg;
+	refcounted_strmap *map;
+	git_strmap *values;
+	khiter_t pos;
+	cvar_t *var;
 	int error = 0;
 
-	if (!h->parent.readonly && ((error = config_file_refresh(cfg)) < 0))
+	if (!h->parent.readonly && ((error = config_refresh(cfg)) < 0))
 		return error;
 
-	if ((error = config_file_entries_take(&entries, h)) < 0)
-		return error;
+	if ((map = refcounted_strmap_take(h)) == NULL)
+		return -1;
+	values = map->values;
 
-	if ((error = (git_config_entries_get(&entry, entries, key))) < 0) {
-		git_config_entries_free(entries);
-		return error;
+	pos = git_strmap_lookup_index(values, key);
+
+	/* no error message; the config system will write one */
+	if (!git_strmap_valid_index(values, pos)) {
+		refcounted_strmap_free(map);
+		return GIT_ENOTFOUND;
 	}
 
-	entry->free = config_file_entry_free;
-	entry->payload = entries;
-	*out = entry;
+	var = git_strmap_value_at(values, pos);
+	while (var->next)
+		var = var->next;
 
-	return 0;
+	*out = var->entry;
+	(*out)->free = release_map;
+	(*out)->payload = map;
+
+	return error;
 }
 
-static int config_file_set_multivar(
+static int config_set_multivar(
 	git_config_backend *cfg, const char *name, const char *regexp, const char *value)
 {
-	config_file_backend *b = GIT_CONTAINER_OF(cfg, config_file_backend, parent);
-	git_regexp preg;
-	int result;
+	diskfile_backend *b = (diskfile_backend *)cfg;
 	char *key;
+	regex_t preg;
+	int result;
 
 	assert(regexp);
 
 	if ((result = git_config__normalize_name(name, &key)) < 0)
 		return result;
 
-	if ((result = git_regexp_compile(&preg, regexp, 0)) < 0)
+	result = p_regcomp(&preg, regexp, REG_EXTENDED);
+	if (result != 0) {
+		giterr_set_regex(&preg, result);
+		result = -1;
 		goto out;
+	}
 
-	/* If we do have it, set call config_file_write() and reload */
-	if ((result = config_file_write(b, name, key, &preg, value)) < 0)
+	/* If we do have it, set call config_write() and reload */
+	if ((result = config_write(b, name, key, &preg, value)) < 0)
 		goto out;
 
+	result = config_refresh(cfg);
+
 out:
 	git__free(key);
-	git_regexp_dispose(&preg);
+	regfree(&preg);
 
 	return result;
 }
 
-static int config_file_delete(git_config_backend *cfg, const char *name)
+static int config_delete(git_config_backend *cfg, const char *name)
 {
-	config_file_backend *b = GIT_CONTAINER_OF(cfg, config_file_backend, parent);
-	git_config_entries *entries = NULL;
-	git_config_entry *entry;
-	char *key = NULL;
-	int error;
+	cvar_t *var;
+	diskfile_backend *b = (diskfile_backend *)cfg;
+	refcounted_strmap *map;	git_strmap *values;
+	char *key;
+	int result;
+	khiter_t pos;
 
-	if ((error = git_config__normalize_name(name, &key)) < 0)
-		goto out;
+	if ((result = git_config__normalize_name(name, &key)) < 0)
+		return result;
 
-	if ((error = config_file_entries_take(&entries, b)) < 0)
-		goto out;
+	if ((map = refcounted_strmap_take(&b->header)) == NULL)
+		return -1;
+	values = b->header.values->values;
 
-	/* Check whether we'd be modifying an included or multivar key */
-	if ((error = git_config_entries_get_unique(&entry, entries, key)) < 0) {
-		if (error == GIT_ENOTFOUND)
-			git_error_set(GIT_ERROR_CONFIG, "could not find key '%s' to delete", name);
-		goto out;
+	pos = git_strmap_lookup_index(values, key);
+	git__free(key);
+
+	if (!git_strmap_valid_index(values, pos)) {
+		refcounted_strmap_free(map);
+		giterr_set(GITERR_CONFIG, "could not find key '%s' to delete", name);
+		return GIT_ENOTFOUND;
 	}
 
-	if ((error = config_file_write(b, name, entry->name, NULL, NULL)) < 0)
-		goto out;
+	var = git_strmap_value_at(values, pos);
+	refcounted_strmap_free(map);
 
-out:
-	git_config_entries_free(entries);
-	git__free(key);
-	return error;
+	if (var->included) {
+		giterr_set(GITERR_CONFIG, "cannot delete included variable");
+		return -1;
+	}
+
+	if (var->next != NULL) {
+		giterr_set(GITERR_CONFIG, "cannot delete multivar with a single delete");
+		return -1;
+	}
+
+	if ((result = config_write(b, name, var->entry->name, NULL, NULL)) < 0)
+		return result;
+
+	return config_refresh(cfg);
 }
 
-static int config_file_delete_multivar(git_config_backend *cfg, const char *name, const char *regexp)
+static int config_delete_multivar(git_config_backend *cfg, const char *name, const char *regexp)
 {
-	config_file_backend *b = GIT_CONTAINER_OF(cfg, config_file_backend, parent);
-	git_config_entries *entries = NULL;
-	git_config_entry *entry = NULL;
-	git_regexp preg = GIT_REGEX_INIT;
-	char *key = NULL;
+	diskfile_backend *b = (diskfile_backend *)cfg;
+	refcounted_strmap *map;
+	git_strmap *values;
+	char *key;
+	regex_t preg;
 	int result;
+	khiter_t pos;
 
 	if ((result = git_config__normalize_name(name, &key)) < 0)
-		goto out;
+		return result;
 
-	if ((result = config_file_entries_take(&entries, b)) < 0)
-		goto out;
+	if ((map = refcounted_strmap_take(&b->header)) == NULL)
+		return -1;
+	values = b->header.values->values;
 
-	if ((result = git_config_entries_get(&entry, entries, key)) < 0) {
-		if (result == GIT_ENOTFOUND)
-			git_error_set(GIT_ERROR_CONFIG, "could not find key '%s' to delete", name);
-		goto out;
+	pos = git_strmap_lookup_index(values, key);
+
+	if (!git_strmap_valid_index(values, pos)) {
+		refcounted_strmap_free(map);
+		git__free(key);
+		giterr_set(GITERR_CONFIG, "could not find key '%s' to delete", name);
+		return GIT_ENOTFOUND;
 	}
 
-	if ((result = git_regexp_compile(&preg, regexp, 0)) < 0)
+	refcounted_strmap_free(map);
+
+	result = p_regcomp(&preg, regexp, REG_EXTENDED);
+	if (result != 0) {
+		giterr_set_regex(&preg, result);
+		result = -1;
 		goto out;
+	}
 
-	if ((result = config_file_write(b, name, key, &preg, NULL)) < 0)
+	if ((result = config_write(b, name, key, &preg, NULL)) < 0)
 		goto out;
 
+	result = config_refresh(cfg);
+
 out:
-	git_config_entries_free(entries);
 	git__free(key);
-	git_regexp_dispose(&preg);
+	regfree(&preg);
 	return result;
 }
 
-static int config_file_lock(git_config_backend *_cfg)
+static int config_snapshot(git_config_backend **out, git_config_backend *in)
+{
+	diskfile_backend *b = (diskfile_backend *) in;
+
+	return git_config_file__snapshot(out, b);
+}
+
+static int config_lock(git_config_backend *_cfg)
 {
-	config_file_backend *cfg = GIT_CONTAINER_OF(_cfg, config_file_backend, parent);
+	diskfile_backend *cfg = (diskfile_backend *) _cfg;
 	int error;
 
 	if ((error = git_filebuf_open(&cfg->locked_buf, cfg->file.path, 0, GIT_CONFIG_FILE_MODE)) < 0)
@@ -458,9 +705,9 @@ static int config_file_lock(git_config_backend *_cfg)
 
 }
 
-static int config_file_unlock(git_config_backend *_cfg, int success)
+static int config_unlock(git_config_backend *_cfg, int success)
 {
-	config_file_backend *cfg = GIT_CONTAINER_OF(_cfg, config_file_backend, parent);
+	diskfile_backend *cfg = (diskfile_backend *) _cfg;
 	int error = 0;
 
 	if (success) {
@@ -469,37 +716,153 @@ static int config_file_unlock(git_config_backend *_cfg, int success)
 	}
 
 	git_filebuf_cleanup(&cfg->locked_buf);
-	git_buf_dispose(&cfg->locked_content);
+	git_buf_free(&cfg->locked_content);
 	cfg->locked = false;
 
 	return error;
 }
 
-int git_config_backend_from_file(git_config_backend **out, const char *path)
+int git_config_file__ondisk(git_config_backend **out, const char *path)
 {
-	config_file_backend *backend;
+	diskfile_backend *backend;
 
-	backend = git__calloc(1, sizeof(config_file_backend));
-	GIT_ERROR_CHECK_ALLOC(backend);
+	backend = git__calloc(1, sizeof(diskfile_backend));
+	GITERR_CHECK_ALLOC(backend);
 
-	backend->parent.version = GIT_CONFIG_BACKEND_VERSION;
-	git_mutex_init(&backend->values_mutex);
+	backend->header.parent.version = GIT_CONFIG_BACKEND_VERSION;
+	git_mutex_init(&backend->header.values_mutex);
 
 	backend->file.path = git__strdup(path);
-	GIT_ERROR_CHECK_ALLOC(backend->file.path);
+	GITERR_CHECK_ALLOC(backend->file.path);
 	git_array_init(backend->file.includes);
 
-	backend->parent.open = config_file_open;
-	backend->parent.get = config_file_get;
-	backend->parent.set = config_file_set;
-	backend->parent.set_multivar = config_file_set_multivar;
-	backend->parent.del = config_file_delete;
-	backend->parent.del_multivar = config_file_delete_multivar;
-	backend->parent.iterator = config_file_iterator;
-	backend->parent.snapshot = config_file_snapshot;
-	backend->parent.lock = config_file_lock;
-	backend->parent.unlock = config_file_unlock;
-	backend->parent.free = config_file_free;
+	backend->header.parent.open = config_open;
+	backend->header.parent.get = config_get;
+	backend->header.parent.set = config_set;
+	backend->header.parent.set_multivar = config_set_multivar;
+	backend->header.parent.del = config_delete;
+	backend->header.parent.del_multivar = config_delete_multivar;
+	backend->header.parent.iterator = config_iterator_new;
+	backend->header.parent.snapshot = config_snapshot;
+	backend->header.parent.lock = config_lock;
+	backend->header.parent.unlock = config_unlock;
+	backend->header.parent.free = backend_free;
+
+	*out = (git_config_backend *)backend;
+
+	return 0;
+}
+
+static int config_set_readonly(git_config_backend *cfg, const char *name, const char *value)
+{
+	GIT_UNUSED(cfg);
+	GIT_UNUSED(name);
+	GIT_UNUSED(value);
+
+	return config_error_readonly();
+}
+
+static int config_set_multivar_readonly(
+	git_config_backend *cfg, const char *name, const char *regexp, const char *value)
+{
+	GIT_UNUSED(cfg);
+	GIT_UNUSED(name);
+	GIT_UNUSED(regexp);
+	GIT_UNUSED(value);
+
+	return config_error_readonly();
+}
+
+static int config_delete_multivar_readonly(git_config_backend *cfg, const char *name, const char *regexp)
+{
+	GIT_UNUSED(cfg);
+	GIT_UNUSED(name);
+	GIT_UNUSED(regexp);
+
+	return config_error_readonly();
+}
+
+static int config_delete_readonly(git_config_backend *cfg, const char *name)
+{
+	GIT_UNUSED(cfg);
+	GIT_UNUSED(name);
+
+	return config_error_readonly();
+}
+
+static int config_lock_readonly(git_config_backend *_cfg)
+{
+	GIT_UNUSED(_cfg);
+
+	return config_error_readonly();
+}
+
+static int config_unlock_readonly(git_config_backend *_cfg, int success)
+{
+	GIT_UNUSED(_cfg);
+	GIT_UNUSED(success);
+
+	return config_error_readonly();
+}
+
+static void backend_readonly_free(git_config_backend *_backend)
+{
+	diskfile_backend *backend = (diskfile_backend *)_backend;
+
+	if (backend == NULL)
+		return;
+
+	refcounted_strmap_free(backend->header.values);
+	git_mutex_free(&backend->header.values_mutex);
+	git__free(backend);
+}
+
+static int config_readonly_open(git_config_backend *cfg, git_config_level_t level, const git_repository *repo)
+{
+	diskfile_readonly_backend *b = (diskfile_readonly_backend *) cfg;
+	diskfile_backend *src = b->snapshot_from;
+	diskfile_header *src_header = &src->header;
+	refcounted_strmap *src_map;
+	int error;
+
+	if (!src_header->parent.readonly && (error = config_refresh(&src_header->parent)) < 0)
+		return error;
+
+	/* We're just copying data, don't care about the level or repo*/
+	GIT_UNUSED(level);
+	GIT_UNUSED(repo);
+
+	if ((src_map = refcounted_strmap_take(src_header)) == NULL)
+		return -1;
+	b->header.values = src_map;
+
+	return 0;
+}
+
+int git_config_file__snapshot(git_config_backend **out, diskfile_backend *in)
+{
+	diskfile_readonly_backend *backend;
+
+	backend = git__calloc(1, sizeof(diskfile_readonly_backend));
+	GITERR_CHECK_ALLOC(backend);
+
+	backend->header.parent.version = GIT_CONFIG_BACKEND_VERSION;
+	git_mutex_init(&backend->header.values_mutex);
+
+	backend->snapshot_from = in;
+
+	backend->header.parent.readonly = 1;
+	backend->header.parent.version = GIT_CONFIG_BACKEND_VERSION;
+	backend->header.parent.open = config_readonly_open;
+	backend->header.parent.get = config_get;
+	backend->header.parent.set = config_set_readonly;
+	backend->header.parent.set_multivar = config_set_multivar_readonly;
+	backend->header.parent.del = config_delete_readonly;
+	backend->header.parent.del_multivar = config_delete_multivar_readonly;
+	backend->header.parent.iterator = config_iterator_new;
+	backend->header.parent.lock = config_lock_readonly;
+	backend->header.parent.unlock = config_unlock_readonly;
+	backend->header.parent.free = backend_readonly_free;
 
 	*out = (git_config_backend *)backend;
 
@@ -541,15 +904,26 @@ static char *escape_value(const char *ptr)
 		ptr++;
 	}
 
-	if (git_buf_oom(&buf))
+	if (git_buf_oom(&buf)) {
+		git_buf_free(&buf);
 		return NULL;
+	}
 
 	return git_buf_detach(&buf);
 }
 
-static int parse_include(config_file_parse_data *parse_data, const char *file)
+struct parse_data {
+	const git_repository *repo;
+	const char *file_path;
+	git_strmap *values;
+	git_config_level_t level;
+	int depth;
+};
+
+static int parse_include(git_config_parser *reader,
+	struct parse_data *parse_data, const char *file)
 {
-	config_file *include;
+	struct config_file *include;
 	git_buf path = GIT_BUF_INIT;
 	char *dir;
 	int result;
@@ -557,7 +931,7 @@ static int parse_include(config_file_parse_data *parse_data, const char *file)
 	if (!file)
 		return 0;
 
-	if ((result = git_path_dirname_r(&path, parse_data->file->path)) < 0)
+	if ((result = git_path_dirname_r(&path, reader->file->path)) < 0)
 		return result;
 
 	dir = git_buf_detach(&path);
@@ -567,17 +941,16 @@ static int parse_include(config_file_parse_data *parse_data, const char *file)
 	if (result < 0)
 		return result;
 
-	include = git_array_alloc(parse_data->file->includes);
-	GIT_ERROR_CHECK_ALLOC(include);
+	include = git_array_alloc(reader->file->includes);
 	memset(include, 0, sizeof(*include));
 	git_array_init(include->includes);
 	include->path = git_buf_detach(&path);
 
-	result = config_file_read(parse_data->entries, parse_data->repo, include,
-				  parse_data->level, parse_data->depth+1);
+	result = config_read(parse_data->values, parse_data->repo,
+		include, parse_data->level, parse_data->depth+1);
 
 	if (result == GIT_ENOTFOUND) {
-		git_error_clear();
+		giterr_clear();
 		result = 0;
 	}
 
@@ -588,41 +961,41 @@ static int do_match_gitdir(
 	int *matches,
 	const git_repository *repo,
 	const char *cfg_file,
-	const char *condition,
+	const char *value,
 	bool case_insensitive)
 {
-	git_buf pattern = GIT_BUF_INIT, gitdir = GIT_BUF_INIT;
-	int error;
-
-	if (condition[0] == '.' && git_path_is_dirsep(condition[1])) {
-		git_path_dirname_r(&pattern, cfg_file);
-		git_buf_joinpath(&pattern, pattern.ptr, condition + 2);
-	} else if (condition[0] == '~' && git_path_is_dirsep(condition[1]))
-		git_sysdir_expand_global_file(&pattern, condition + 1);
-	else if (!git_path_is_absolute(condition))
-		git_buf_joinpath(&pattern, "**", condition);
+	git_buf path = GIT_BUF_INIT;
+	int error, fnmatch_flags;
+
+	if (value[0] == '.' && git_path_is_dirsep(value[1])) {
+		git_path_dirname_r(&path, cfg_file);
+		git_buf_joinpath(&path, path.ptr, value + 2);
+	} else if (value[0] == '~' && git_path_is_dirsep(value[1]))
+		git_sysdir_expand_global_file(&path, value + 1);
+	else if (!git_path_is_absolute(value))
+		git_buf_joinpath(&path, "**", value);
 	else
-		git_buf_sets(&pattern, condition);
+		git_buf_sets(&path, value);
 
-	if (git_path_is_dirsep(condition[strlen(condition) - 1]))
-		git_buf_puts(&pattern, "**");
-
-	if (git_buf_oom(&pattern)) {
+	if (git_buf_oom(&path)) {
 		error = -1;
 		goto out;
 	}
 
-	if ((error = git_repository_item_path(&gitdir, repo, GIT_REPOSITORY_ITEM_GITDIR)) < 0)
+	if (git_path_is_dirsep(value[strlen(value) - 1]))
+		git_buf_puts(&path, "**");
+
+	fnmatch_flags = FNM_PATHNAME|FNM_LEADING_DIR;
+	if (case_insensitive)
+		fnmatch_flags |= FNM_IGNORECASE;
+
+	if ((error = p_fnmatch(path.ptr, git_repository_path(repo), fnmatch_flags)) < 0)
 		goto out;
 
-	if (git_path_is_dirsep(gitdir.ptr[gitdir.size - 1]))
-		git_buf_truncate(&gitdir, gitdir.size - 1);
+	*matches = (error == 0);
 
-	*matches = wildmatch(pattern.ptr, gitdir.ptr,
-			     WM_PATHNAME | (case_insensitive ? WM_CASEFOLD : 0)) == WM_MATCH;
 out:
-	git_buf_dispose(&pattern);
-	git_buf_dispose(&gitdir);
+	git_buf_free(&path);
 	return error;
 }
 
@@ -644,67 +1017,16 @@ static int conditional_match_gitdir_i(
 	return do_match_gitdir(matches, repo, cfg_file, value, true);
 }
 
-static int conditional_match_onbranch(
-	int *matches,
-	const git_repository *repo,
-	const char *cfg_file,
-	const char *condition)
-{
-	git_buf reference = GIT_BUF_INIT, buf = GIT_BUF_INIT;
-	int error;
-
-	GIT_UNUSED(cfg_file);
-
-	/*
-	 * NOTE: you cannot use `git_repository_head` here. Looking up the
-	 * HEAD reference will create the ODB, which causes us to read the
-	 * repo's config for keys like core.precomposeUnicode. As we're
-	 * just parsing the config right now, though, this would result in
-	 * an endless recursion.
-	 */
-
-	if ((error = git_buf_joinpath(&buf, git_repository_path(repo), GIT_HEAD_FILE)) < 0 ||
-	    (error = git_futils_readbuffer(&reference, buf.ptr)) < 0)
-		goto out;
-	git_buf_rtrim(&reference);
-
-	if (git__strncmp(reference.ptr, GIT_SYMREF, strlen(GIT_SYMREF)))
-		goto out;
-	git_buf_consume(&reference, reference.ptr + strlen(GIT_SYMREF));
-
-	if (git__strncmp(reference.ptr, GIT_REFS_HEADS_DIR, strlen(GIT_REFS_HEADS_DIR)))
-		goto out;
-	git_buf_consume(&reference, reference.ptr + strlen(GIT_REFS_HEADS_DIR));
-
-	/*
-	 * If the condition ends with a '/', then we should treat it as if
-	 * it had '**' appended.
-	 */
-	if ((error = git_buf_sets(&buf, condition)) < 0)
-		goto out;
-	if (git_path_is_dirsep(condition[strlen(condition) - 1]) &&
-	    (error = git_buf_puts(&buf, "**")) < 0)
-		goto out;
-
-	*matches = wildmatch(buf.ptr, reference.ptr, WM_PATHNAME) == WM_MATCH;
-out:
-	git_buf_dispose(&reference);
-	git_buf_dispose(&buf);
-
-	return error;
-
-}
-
 static const struct {
 	const char *prefix;
 	int (*matches)(int *matches, const git_repository *repo, const char *cfg, const char *value);
 } conditions[] = {
 	{ "gitdir:", conditional_match_gitdir },
-	{ "gitdir/i:", conditional_match_gitdir_i },
-	{ "onbranch:", conditional_match_onbranch }
+	{ "gitdir/i:", conditional_match_gitdir_i }
 };
 
-static int parse_conditional_include(config_file_parse_data *parse_data, const char *section, const char *file)
+static int parse_conditional_include(git_config_parser *reader,
+	struct parse_data *parse_data, const char *section, const char *file)
 {
 	char *condition;
 	size_t i;
@@ -722,12 +1044,12 @@ static int parse_conditional_include(config_file_parse_data *parse_data, const c
 
 		if ((error = conditions[i].matches(&matches,
 						   parse_data->repo,
-						   parse_data->file->path,
+						   parse_data->file_path,
 						   condition + strlen(conditions[i].prefix))) < 0)
 			break;
 
 		if (matches)
-			error = parse_include(parse_data, file);
+			error = parse_include(reader, parse_data, file);
 
 		break;
 	}
@@ -739,19 +1061,17 @@ static int parse_conditional_include(config_file_parse_data *parse_data, const c
 static int read_on_variable(
 	git_config_parser *reader,
 	const char *current_section,
-	const char *var_name,
-	const char *var_value,
+	char *var_name,
+	char *var_value,
 	const char *line,
 	size_t line_len,
 	void *data)
 {
-	config_file_parse_data *parse_data = (config_file_parse_data *)data;
+	struct parse_data *parse_data = (struct parse_data *)data;
 	git_buf buf = GIT_BUF_INIT;
-	git_config_entry *entry;
-	const char *c;
+	cvar_t *var;
 	int result = 0;
 
-	GIT_UNUSED(reader);
 	GIT_UNUSED(line);
 	GIT_UNUSED(line_len);
 
@@ -763,104 +1083,85 @@ static int read_on_variable(
 		git_buf_puts(&buf, current_section);
 		git_buf_putc(&buf, '.');
 	}
+	git__strtolower(var_name);
+	git_buf_puts(&buf, var_name);
+	git__free(var_name);
 
-	for (c = var_name; *c; c++)
-		git_buf_putc(&buf, git__tolower(*c));
-
-	if (git_buf_oom(&buf))
+	if (git_buf_oom(&buf)) {
+		git__free(var_value);
 		return -1;
+	}
+
+	var = git__calloc(1, sizeof(cvar_t));
+	GITERR_CHECK_ALLOC(var);
+	var->entry = git__calloc(1, sizeof(git_config_entry));
+	GITERR_CHECK_ALLOC(var->entry);
 
-	entry = git__calloc(1, sizeof(git_config_entry));
-	GIT_ERROR_CHECK_ALLOC(entry);
-	entry->name = git_buf_detach(&buf);
-	entry->value = var_value ? git__strdup(var_value) : NULL;
-	entry->level = parse_data->level;
-	entry->include_depth = parse_data->depth;
+	var->entry->name = git_buf_detach(&buf);
+	var->entry->value = var_value;
+	var->entry->level = parse_data->level;
+	var->included = !!parse_data->depth;
 
-	if ((result = git_config_entries_append(parse_data->entries, entry)) < 0)
+	if ((result = append_entry(parse_data->values, var)) < 0)
 		return result;
 
 	result = 0;
 
 	/* Add or append the new config option */
-	if (!git__strcmp(entry->name, "include.path"))
-		result = parse_include(parse_data, entry->value);
-	else if (!git__prefixcmp(entry->name, "includeif.") &&
-	         !git__suffixcmp(entry->name, ".path"))
-		result = parse_conditional_include(parse_data, entry->name, entry->value);
+	if (!git__strcmp(var->entry->name, "include.path"))
+		result = parse_include(reader, parse_data, var->entry->value);
+	else if (!git__prefixcmp(var->entry->name, "includeif.") &&
+	         !git__suffixcmp(var->entry->name, ".path"))
+		result = parse_conditional_include(reader, parse_data,
+						   var->entry->name, var->entry->value);
+
 
 	return result;
 }
 
-static int config_file_read_buffer(
-	git_config_entries *entries,
+static int config_read(
+	git_strmap *values,
 	const git_repository *repo,
-	config_file *file,
+	git_config_file *file,
 	git_config_level_t level,
-	int depth,
-	const char *buf,
-	size_t buflen)
+	int depth)
 {
-	config_file_parse_data parse_data;
+	struct parse_data parse_data;
 	git_config_parser reader;
+	git_buf contents = GIT_BUF_INIT;
 	int error;
 
 	if (depth >= MAX_INCLUDE_DEPTH) {
-		git_error_set(GIT_ERROR_CONFIG, "maximum config include depth reached");
+		giterr_set(GITERR_CONFIG, "maximum config include depth reached");
 		return -1;
 	}
 
+	if ((error = git_futils_readbuffer(&contents, file->path)) < 0)
+		goto out;
+
+	git_parse_ctx_init(&reader.ctx, contents.ptr, contents.size);
+
+	if ((error = git_hash_buf(&file->checksum, contents.ptr, contents.size)) < 0)
+		goto out;
+
 	/* Initialize the reading position */
-	reader.path = file->path;
-	git_parse_ctx_init(&reader.ctx, buf, buflen);
+	reader.file = file;
+	git_parse_ctx_init(&reader.ctx, contents.ptr, contents.size);
 
 	/* If the file is empty, there's nothing for us to do */
-	if (!reader.ctx.content || *reader.ctx.content == '\0') {
-		error = 0;
+	if (!reader.ctx.content || *reader.ctx.content == '\0')
 		goto out;
-	}
 
 	parse_data.repo = repo;
-	parse_data.file = file;
-	parse_data.entries = entries;
+	parse_data.file_path = file->path;
+	parse_data.values = values;
 	parse_data.level = level;
 	parse_data.depth = depth;
 
 	error = git_config_parse(&reader, NULL, read_on_variable, NULL, NULL, &parse_data);
 
 out:
-	return error;
-}
-
-static int config_file_read(
-	git_config_entries *entries,
-	const git_repository *repo,
-	config_file *file,
-	git_config_level_t level,
-	int depth)
-{
-	git_buf contents = GIT_BUF_INIT;
-	struct stat st;
-	int error;
-
-	if (p_stat(file->path, &st) < 0) {
-		error = git_path_set_error(errno, file->path, "stat");
-		goto out;
-	}
-
-	if ((error = git_futils_readbuffer(&contents, file->path)) < 0)
-		goto out;
-
-	git_futils_filestamp_set_from_stat(&file->stamp, &st);
-	if ((error = git_hash_buf(&file->checksum, contents.ptr, contents.size)) < 0)
-		goto out;
-
-	if ((error = config_file_read_buffer(entries, repo, file, level, depth,
-					     contents.ptr, contents.size)) < 0)
-		goto out;
-
-out:
-	git_buf_dispose(&contents);
+	git_buf_free(&contents);
 	return error;
 }
 
@@ -879,7 +1180,7 @@ static int write_section(git_buf *fbuf, const char *key)
 		char *escaped;
 		git_buf_put(&buf, key, dot - key);
 		escaped = escape_value(dot + 1);
-		GIT_ERROR_CHECK_ALLOC(escaped);
+		GITERR_CHECK_ALLOC(escaped);
 		git_buf_printf(&buf, " \"%s\"", escaped);
 		git__free(escaped);
 	}
@@ -889,7 +1190,7 @@ static int write_section(git_buf *fbuf, const char *key)
 		return -1;
 
 	result = git_buf_put(fbuf, git_buf_cstr(&buf), buf.size);
-	git_buf_dispose(&buf);
+	git_buf_free(&buf);
 
 	return result;
 }
@@ -921,7 +1222,7 @@ struct write_data {
 	const char *section;
 	const char *orig_name;
 	const char *name;
-	const git_regexp *preg;
+	const regex_t *preg;
 	const char *value;
 };
 
@@ -998,8 +1299,8 @@ static int write_on_section(
 static int write_on_variable(
 	git_config_parser *reader,
 	const char *current_section,
-	const char *var_name,
-	const char *var_value,
+	char *var_name,
+	char *var_value,
 	const char *line,
 	size_t line_len,
 	void *data)
@@ -1026,7 +1327,10 @@ static int write_on_variable(
 
 	/* If we have a regex to match the value, see if it matches */
 	if (has_matched && write_data->preg != NULL)
-		has_matched = (git_regexp_match(write_data->preg, var_value) == 0);
+		has_matched = (regexec(write_data->preg, var_value, 0, NULL, 0) == 0);
+
+	git__free(var_name);
+	git__free(var_value);
 
 	/* If this isn't the name/value we're looking for, simply dump the
 	 * existing data back out and continue on.
@@ -1087,79 +1391,89 @@ static int write_on_eof(
 /*
  * This is pretty much the parsing, except we write out anything we don't have
  */
-static int config_file_write(config_file_backend *cfg, const char *orig_key, const char *key, const git_regexp *preg, const char* value)
-
+static int config_write(diskfile_backend *cfg, const char *orig_key, const char *key, const regex_t *preg, const char* value)
 {
-	char *orig_section = NULL, *section = NULL, *orig_name, *name, *ldot;
-	git_buf buf = GIT_BUF_INIT, contents = GIT_BUF_INIT;
-	git_config_parser parser = GIT_CONFIG_PARSER_INIT;
+	int result;
+	char *orig_section, *section, *orig_name, *name, *ldot;
 	git_filebuf file = GIT_FILEBUF_INIT;
+	git_buf buf = GIT_BUF_INIT, contents = GIT_BUF_INIT;
+	git_config_parser reader;
 	struct write_data write_data;
-	int error;
 
-	memset(&write_data, 0, sizeof(write_data));
+	memset(&reader, 0, sizeof(reader));
+	reader.file = &cfg->file;
 
 	if (cfg->locked) {
-		error = git_buf_puts(&contents, git_buf_cstr(&cfg->locked_content) == NULL ? "" : git_buf_cstr(&cfg->locked_content));
+		result = git_buf_puts(&contents, git_buf_cstr(&cfg->locked_content));
 	} else {
-		if ((error = git_filebuf_open(&file, cfg->file.path, GIT_FILEBUF_HASH_CONTENTS,
-					      GIT_CONFIG_FILE_MODE)) < 0)
-			goto done;
+		/* Lock the file */
+		if ((result = git_filebuf_open(
+			     &file, cfg->file.path, GIT_FILEBUF_HASH_CONTENTS, GIT_CONFIG_FILE_MODE)) < 0) {
+			git_buf_free(&contents);
+			return result;
+		}
 
 		/* We need to read in our own config file */
-		error = git_futils_readbuffer(&contents, cfg->file.path);
+		result = git_futils_readbuffer(&contents, cfg->file.path);
 	}
-	if (error < 0 && error != GIT_ENOTFOUND)
-		goto done;
 
-	if ((git_config_parser_init(&parser, cfg->file.path, contents.ptr, contents.size)) < 0)
-		goto done;
+	/* Initialise the reading position */
+	if (result == 0 || result == GIT_ENOTFOUND) {
+		git_parse_ctx_init(&reader.ctx, contents.ptr, contents.size);
+	} else {
+		git_filebuf_cleanup(&file);
+		return -1; /* OS error when reading the file */
+	}
 
 	ldot = strrchr(key, '.');
 	name = ldot + 1;
 	section = git__strndup(key, ldot - key);
-	GIT_ERROR_CHECK_ALLOC(section);
+	GITERR_CHECK_ALLOC(section);
 
 	ldot = strrchr(orig_key, '.');
 	orig_name = ldot + 1;
 	orig_section = git__strndup(orig_key, ldot - orig_key);
-	GIT_ERROR_CHECK_ALLOC(orig_section);
+	GITERR_CHECK_ALLOC(orig_section);
 
 	write_data.buf = &buf;
+	git_buf_init(&write_data.buffered_comment, 0);
 	write_data.orig_section = orig_section;
 	write_data.section = section;
+	write_data.in_section = 0;
+	write_data.preg_replaced = 0;
 	write_data.orig_name = orig_name;
 	write_data.name = name;
 	write_data.preg = preg;
 	write_data.value = value;
 
-	if ((error = git_config_parse(&parser, write_on_section, write_on_variable,
-				      write_on_comment, write_on_eof, &write_data)) < 0)
+	result = git_config_parse(&reader,
+		write_on_section,
+		write_on_variable,
+		write_on_comment,
+		write_on_eof,
+		&write_data);
+	git__free(section);
+	git__free(orig_section);
+	git_buf_free(&write_data.buffered_comment);
+
+	if (result < 0) {
+		git_filebuf_cleanup(&file);
 		goto done;
+	}
 
 	if (cfg->locked) {
 		size_t len = buf.asize;
 		/* Update our copy with the modified contents */
-		git_buf_dispose(&cfg->locked_content);
+		git_buf_free(&cfg->locked_content);
 		git_buf_attach(&cfg->locked_content, git_buf_detach(&buf), len);
 	} else {
 		git_filebuf_write(&file, git_buf_cstr(&buf), git_buf_len(&buf));
-
-		if ((error = git_filebuf_commit(&file)) < 0)
-			goto done;
-
-		if ((error = config_file_refresh_from_buffer(&cfg->parent, buf.ptr, buf.size)) < 0)
-			goto done;
+		result = git_filebuf_commit(&file);
 	}
 
 done:
-	git__free(section);
-	git__free(orig_section);
-	git_buf_dispose(&write_data.buffered_comment);
-	git_buf_dispose(&buf);
-	git_buf_dispose(&contents);
-	git_filebuf_cleanup(&file);
-	git_config_parser_dispose(&parser);
-
-	return error;
+	git_buf_free(&buf);
+	git_buf_free(&contents);
+	git_parse_ctx_clear(&reader.ctx);
+	return result;
 }