rugged 0.27.10.1 → 0.28.0

data/vendor/libgit2/src/config.h

@@ -24,7 +24,7 @@
 
 struct git_config {
 	git_refcount rc;
-	git_vector files;
+	git_vector backends;
 };
 
 extern int git_config__global_location(git_buf *buf);
@@ -34,19 +34,6 @@ 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 */

data/vendor/libgit2/src/config_backend.h

@@ -0,0 +1,84 @@
+/*
+ * 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.
+ */
+#ifndef INCLUDE_config_file_h__
+#define INCLUDE_config_file_h__
+
+#include "common.h"
+
+#include "git2/sys/config.h"
+#include "git2/config.h"
+
+/**
+ * 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_backend_from_file(git_config_backend **out, const char *path);
+
+/**
+ * Create an in-memory configuration file backend
+ *
+ * @param out the new backend
+ * @param cfg the configuration that is to be parsed
+ * @param len the length of the string pointed to by `cfg`
+ */
+extern int git_config_backend_from_string(git_config_backend **out, const char *cfg, size_t len);
+
+GIT_INLINE(int) git_config_backend_open(git_config_backend *cfg, unsigned int level, const git_repository *repo)
+{
+	return cfg->open(cfg, level, repo);
+}
+
+GIT_INLINE(void) git_config_backend_free(git_config_backend *cfg)
+{
+	if (cfg)
+		cfg->free(cfg);
+}
+
+GIT_INLINE(int) git_config_backend_get_string(
+	git_config_entry **out, git_config_backend *cfg, const char *name)
+{
+	return cfg->get(cfg, name, out);
+}
+
+GIT_INLINE(int) git_config_backend_set_string(
+	git_config_backend *cfg, const char *name, const char *value)
+{
+	return cfg->set(cfg, name, value);
+}
+
+GIT_INLINE(int) git_config_backend_delete(
+	git_config_backend *cfg, const char *name)
+{
+	return cfg->del(cfg, name);
+}
+
+GIT_INLINE(int) git_config_backend_foreach(
+	git_config_backend *cfg,
+	int (*fn)(const git_config_entry *entry, void *data),
+	void *data)
+{
+	return git_config_backend_foreach_match(cfg, NULL, fn, data);
+}
+
+GIT_INLINE(int) git_config_backend_lock(git_config_backend *cfg)
+{
+	return cfg->lock(cfg);
+}
+
+GIT_INLINE(int) git_config_backend_unlock(git_config_backend *cfg, int success)
+{
+	return cfg->unlock(cfg, success);
+}
+
+#endif

data/vendor/libgit2/src/config_cache.c

@@ -58,6 +58,12 @@ static git_cvar_map _cvar_map_safecrlf[] = {
 	{GIT_CVAR_STRING, "warn", GIT_SAFE_CRLF_WARN}
 };
 
+static git_cvar_map _cvar_map_logallrefupdates[] = {
+	{GIT_CVAR_FALSE, NULL, GIT_LOGALLREFUPDATES_FALSE},
+	{GIT_CVAR_TRUE, NULL, GIT_LOGALLREFUPDATES_TRUE},
+	{GIT_CVAR_STRING, "always", GIT_LOGALLREFUPDATES_ALWAYS},
+};
+
 /*
  * Generic map for integer values
  */
@@ -76,7 +82,7 @@ static struct map_data _cvar_maps[] = {
 	{"core.abbrev", _cvar_map_int, 1, GIT_ABBREV_DEFAULT },
 	{"core.precomposeunicode", NULL, 0, GIT_PRECOMPOSE_DEFAULT },
 	{"core.safecrlf", _cvar_map_safecrlf, ARRAY_SIZE(_cvar_map_safecrlf), GIT_SAFE_CRLF_DEFAULT},
-	{"core.logallrefupdates", NULL, 0, GIT_LOGALLREFUPDATES_DEFAULT },
+	{"core.logallrefupdates", _cvar_map_logallrefupdates, ARRAY_SIZE(_cvar_map_logallrefupdates), GIT_LOGALLREFUPDATES_DEFAULT},
 	{"core.protecthfs", NULL, 0, GIT_PROTECTHFS_DEFAULT },
 	{"core.protectntfs", NULL, 0, GIT_PROTECTNTFS_DEFAULT },
 	{"core.fsyncobjectfiles", NULL, 0, GIT_FSYNCOBJECTFILES_DEFAULT },

data/vendor/libgit2/src/config_entries.c

@@ -0,0 +1,259 @@
+/*
+ * 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 "config_entries.h"
+
+typedef struct config_entry_list {
+	struct config_entry_list *next;
+	struct config_entry_list *last;
+	git_config_entry *entry;
+} config_entry_list;
+
+typedef struct config_entries_iterator {
+	git_config_iterator parent;
+	git_config_entries *entries;
+	config_entry_list *head;
+} config_entries_iterator;
+
+struct git_config_entries {
+	git_refcount rc;
+	git_strmap *map;
+	config_entry_list *list;
+};
+
+static void config_entry_list_free(config_entry_list *list)
+{
+	config_entry_list *next;
+
+	while (list != NULL) {
+		next = list->next;
+
+		git__free((char*) list->entry->name);
+		git__free((char *) list->entry->value);
+		git__free(list->entry);
+		git__free(list);
+
+		list = next;
+	};
+}
+
+static void config_entry_list_append(config_entry_list **list, config_entry_list *entry)
+{
+	if (*list)
+		(*list)->last->next = entry;
+	else
+		*list = entry;
+	(*list)->last = entry;
+}
+
+int git_config_entries_new(git_config_entries **out)
+{
+	git_config_entries *entries;
+	int error;
+
+	entries = git__calloc(1, sizeof(git_config_entries));
+	GIT_ERROR_CHECK_ALLOC(entries);
+	GIT_REFCOUNT_INC(entries);
+
+	if ((error = git_strmap_alloc(&entries->map)) < 0)
+		git__free(entries);
+	else
+		*out = entries;
+
+	return error;
+}
+
+int git_config_entries_dup(git_config_entries **out, git_config_entries *entries)
+{
+	git_config_entries *result = NULL;
+	config_entry_list *head;
+	int error;
+
+	if ((error = git_config_entries_new(&result)) < 0)
+		goto out;
+
+	for (head = entries->list; head; head = head->next) {
+		git_config_entry *dup;
+
+		dup = git__calloc(1, sizeof(git_config_entry));
+		dup->name = git__strdup(head->entry->name);
+		GIT_ERROR_CHECK_ALLOC(dup->name);
+		if (head->entry->value) {
+			dup->value = git__strdup(head->entry->value);
+			GIT_ERROR_CHECK_ALLOC(dup->value);
+		}
+		dup->level = head->entry->level;
+		dup->include_depth = head->entry->include_depth;
+
+		if ((error = git_config_entries_append(result, dup)) < 0)
+			goto out;
+	}
+
+	*out = result;
+	result = NULL;
+
+out:
+	git_config_entries_free(result);
+	return error;
+}
+
+void git_config_entries_incref(git_config_entries *entries)
+{
+	GIT_REFCOUNT_INC(entries);
+}
+
+static void config_entries_free(git_config_entries *entries)
+{
+	config_entry_list *list = NULL, *next;
+
+	git_strmap_foreach_value(entries->map, list, config_entry_list_free(list));
+	git_strmap_free(entries->map);
+
+	list = entries->list;
+	while (list != NULL) {
+		next = list->next;
+		git__free(list);
+		list = next;
+	}
+
+	git__free(entries);
+}
+
+void git_config_entries_free(git_config_entries *entries)
+{
+	if (entries)
+		GIT_REFCOUNT_DEC(entries, config_entries_free);
+}
+
+int git_config_entries_append(git_config_entries *entries, git_config_entry *entry)
+{
+	config_entry_list *existing, *var;
+	int error = 0;
+	size_t pos;
+
+	var = git__calloc(1, sizeof(config_entry_list));
+	GIT_ERROR_CHECK_ALLOC(var);
+	var->entry = entry;
+
+	pos = git_strmap_lookup_index(entries->map, entry->name);
+	if (!git_strmap_valid_index(entries->map, pos)) {
+		/*
+		 * We only ever inspect `last` from the first config
+		 * entry in a multivar. In case where this new entry is
+		 * the first one in the entry map, it will also be the
+		 * last one at the time of adding it, which is
+		 * why we set `last` here to itself. Otherwise we
+		 * do not have to set `last` and leave it set to
+		 * `NULL`.
+		 */
+		var->last = var;
+
+		git_strmap_insert(entries->map, entry->name, var, &error);
+
+		if (error > 0)
+			error = 0;
+	} else {
+		existing = git_strmap_value_at(entries->map, pos);
+		config_entry_list_append(&existing, var);
+	}
+
+	var = git__calloc(1, sizeof(config_entry_list));
+	GIT_ERROR_CHECK_ALLOC(var);
+	var->entry = entry;
+	config_entry_list_append(&entries->list, var);
+
+	return error;
+}
+
+int config_entry_get(config_entry_list **out, git_config_entries *entries, const char *key)
+{
+	size_t pos;
+
+	pos = git_strmap_lookup_index(entries->map, key);
+
+	/* no error message; the config system will write one */
+	if (!git_strmap_valid_index(entries->map, pos))
+		return GIT_ENOTFOUND;
+
+	*out = git_strmap_value_at(entries->map, pos);
+
+	return 0;
+}
+
+int git_config_entries_get(git_config_entry **out, git_config_entries *entries, const char *key)
+{
+	config_entry_list *entry;
+	int error;
+
+	if ((error = config_entry_get(&entry, entries, key)) < 0)
+		return error;
+	*out = entry->last->entry;
+
+	return 0;
+}
+
+int git_config_entries_get_unique(git_config_entry **out, git_config_entries *entries, const char *key)
+{
+	config_entry_list *entry;
+	int error;
+
+	if ((error = config_entry_get(&entry, entries, key)) < 0)
+		return error;
+
+	if (entry->next != NULL) {
+		git_error_set(GIT_ERROR_CONFIG, "entry is not unique due to being a multivar");
+		return -1;
+	}
+
+	if (entry->entry->include_depth) {
+		git_error_set(GIT_ERROR_CONFIG, "entry is not unique due to being included");
+		return -1;
+	}
+
+	*out = entry->entry;
+
+	return 0;
+}
+
+void config_iterator_free(git_config_iterator *iter)
+{
+	config_entries_iterator *it = (config_entries_iterator *) iter;
+	git_config_entries_free(it->entries);
+	git__free(it);
+}
+
+int config_iterator_next(
+	git_config_entry **entry,
+	git_config_iterator *iter)
+{
+	config_entries_iterator *it = (config_entries_iterator *) iter;
+
+	if (!it->head)
+		return GIT_ITEROVER;
+
+	*entry = it->head->entry;
+	it->head = it->head->next;
+
+	return 0;
+}
+
+int git_config_entries_iterator_new(git_config_iterator **out, git_config_entries *entries)
+{
+	config_entries_iterator *it;
+
+	it = git__calloc(1, sizeof(config_entries_iterator));
+	GIT_ERROR_CHECK_ALLOC(it);
+	it->parent.next = config_iterator_next;
+	it->parent.free = config_iterator_free;
+	it->head = entries->list;
+	it->entries = entries;
+
+	git_config_entries_incref(entries);
+	*out = &it->parent;
+
+	return 0;
+}

data/vendor/libgit2/src/config_entries.h

@@ -0,0 +1,23 @@
+/*
+ * 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 "git2/sys/config.h"
+#include "config.h"
+
+typedef struct git_config_entries git_config_entries;
+
+int git_config_entries_new(git_config_entries **out);
+int git_config_entries_dup(git_config_entries **out, git_config_entries *entries);
+void git_config_entries_incref(git_config_entries *entries);
+void git_config_entries_free(git_config_entries *entries);
+/* Add or append the new config option */
+int git_config_entries_append(git_config_entries *entries, git_config_entry *entry);
+int git_config_entries_get(git_config_entry **out, git_config_entries *entries, const char *key);
+int git_config_entries_get_unique(git_config_entry **out, git_config_entries *entries, const char *key);
+int git_config_entries_iterator_new(git_config_iterator **out, git_config_entries *entries);

data/vendor/libgit2/src/config_file.c

@@ -5,9 +5,8 @@
  * a Linking Exception. For full terms see the included COPYING file.
  */
 
-#include "config_file.h"
-
 #include "config.h"
+
 #include "filebuf.h"
 #include "sysdir.h"
 #include "buffer.h"
@@ -18,74 +17,20 @@
 #include "strmap.h"
 #include "array.h"
 #include "config_parse.h"
+#include "config_entries.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
 
-#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;
-	refcounted_strmap *values;
+	git_config_entries *entries;
 	const git_repository *repo;
 	git_config_level_t level;
 } diskfile_header;
@@ -108,144 +53,46 @@ typedef struct {
 	diskfile_backend *snapshot_from;
 } diskfile_readonly_backend;
 
-static int config_read(git_strmap *values, const git_repository *repo, git_config_file *file, git_config_level_t level, int depth);
+typedef struct {
+	const git_repository *repo;
+	const char *file_path;
+	git_config_entries *entries;
+	git_config_level_t level;
+	unsigned int depth;
+} diskfile_parse_state;
+
+static int config_read(git_config_entries *entries, 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");
+	git_error_set(GIT_ERROR_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 refcounted_strmap *refcounted_strmap_take(diskfile_header *h)
+static git_config_entries *diskfile_entries_take(diskfile_header *h)
 {
-	refcounted_strmap *map;
+	git_config_entries *entries;
 
 	if (git_mutex_lock(&h->values_mutex) < 0) {
-	    giterr_set(GITERR_OS, "failed to lock config backend");
+	    git_error_set(GIT_ERROR_OS, "failed to lock config backend");
 	    return NULL;
 	}
 
-	map = h->values;
-	git_atomic_inc(&map->refcount);
+	entries = h->entries;
+	git_config_entries_incref(entries);
 
 	git_mutex_unlock(&h->values_mutex);
 
-	return map;
-}
-
-static int refcounted_strmap_alloc(refcounted_strmap **out)
-{
-	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;
+	return entries;
 }
 
 static void config_file_clear(struct config_file *file)
@@ -272,15 +119,15 @@ static int config_open(git_config_backend *cfg, git_config_level_t level, const
 	b->header.level = level;
 	b->header.repo = repo;
 
-	if ((res = refcounted_strmap_alloc(&b->header.values)) < 0)
+	if ((res = git_config_entries_new(&b->header.entries)) < 0)
 		return res;
 
 	if (!git_path_exists(b->file.path))
 		return 0;
 
-	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;
+	if (res < 0 || (res = config_read(b->header.entries, repo, &b->file, level, 0)) < 0) {
+		git_config_entries_free(b->header.entries);
+		b->header.entries = NULL;
 	}
 
 	return res;
@@ -313,7 +160,7 @@ static int config_is_modified(int *modified, struct config_file *file)
 	}
 
 out:
-	git_buf_free(&buf);
+	git_buf_dispose(&buf);
 
 	return error;
 }
@@ -321,7 +168,7 @@ out:
 static int config_refresh(git_config_backend *cfg)
 {
 	diskfile_backend *b = (diskfile_backend *)cfg;
-	refcounted_strmap *values = NULL, *tmp;
+	git_config_entries *entries = NULL, *tmp;
 	git_config_file *include;
 	int error, modified;
 	uint32_t i;
@@ -336,7 +183,7 @@ static int config_refresh(git_config_backend *cfg)
 	if (!modified)
 		return 0;
 
-	if ((error = refcounted_strmap_alloc(&values)) < 0)
+	if ((error = git_config_entries_new(&entries)) < 0)
 		goto out;
 
 	/* Reparse the current configuration */
@@ -345,22 +192,22 @@ static int config_refresh(git_config_backend *cfg)
 	}
 	git_array_clear(b->file.includes);
 
-	if ((error = config_read(values->values, b->header.repo, &b->file, b->header.level, 0)) < 0)
+	if ((error = config_read(entries, b->header.repo, &b->file, b->header.level, 0)) < 0)
 		goto out;
 
 	if ((error = git_mutex_lock(&b->header.values_mutex)) < 0) {
-		giterr_set(GITERR_OS, "failed to lock config backend");
+		git_error_set(GIT_ERROR_OS, "failed to lock config backend");
 		goto out;
 	}
 
-	tmp = b->header.values;
-	b->header.values = values;
-	values = tmp;
+	tmp = b->header.entries;
+	b->header.entries = entries;
+	entries = tmp;
 
 	git_mutex_unlock(&b->header.values_mutex);
 
 out:
-	refcounted_strmap_free(values);
+	git_config_entries_free(entries);
 
 	return (error == GIT_ENOTFOUND) ? 0 : error;
 }
@@ -373,149 +220,80 @@ static void backend_free(git_config_backend *_backend)
 		return;
 
 	config_file_clear(&backend->file);
-	refcounted_strmap_free(backend->header.values);
+	git_config_entries_free(backend->header.entries);
 	git_mutex_free(&backend->header.values_mutex);
 	git__free(backend);
 }
 
-static void config_iterator_free(
-	git_config_iterator* iter)
-{
-	iter->backend->free(iter->backend);
-	git__free(iter);
-}
-
-static int config_iterator_next(
-	git_config_entry **entry,
-	git_config_iterator *iter)
-{
-	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_iterator_new(
 	git_config_iterator **iter,
 	struct git_config_backend* backend)
 {
-	diskfile_header *h;
-	git_config_file_iter *it;
-	git_config_backend *snapshot;
 	diskfile_header *bh = (diskfile_header *) backend;
+	git_config_entries *entries;
 	int error;
 
-	if ((error = config_snapshot(&snapshot, backend)) < 0)
+	if ((error = git_config_entries_dup(&entries, bh->entries)) < 0)
 		return error;
 
-	if ((error = snapshot->open(snapshot, bh->level, bh->repo)) < 0)
-		return error;
-
-	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;
+	if ((error = git_config_entries_iterator_new(iter, entries)) < 0)
+		goto out;
 
-	return 0;
+out:
+	/* Let iterator delete duplicated entries when it's done */
+	git_config_entries_free(entries);
+	return error;
 }
 
 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;
+	git_config_entries *entries;
+	git_config_entry *existing;
 	char *key, *esc_value = NULL;
-	khiter_t pos;
-	int rval, ret;
+	int error;
 
-	if ((rval = git_config__normalize_name(name, &key)) < 0)
-		return rval;
+	if ((error = git_config__normalize_name(name, &key)) < 0)
+		return error;
 
-	if ((map = refcounted_strmap_take(&b->header)) == NULL)
+	if ((entries = diskfile_entries_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;
+	/* 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)
 			goto out;
-		}
-
-		if (existing->included) {
-			giterr_set(GITERR_CONFIG, "modifying included variable is not supported");
-			ret = -1;
-			goto out;
-		}
-
+		error = 0;
+	} else if ((!existing->value && !value) ||
+		   (existing->value && value && !strcmp(existing->value, value))) {
 		/* don't update if old and new values already match */
-		if ((!existing->entry->value && !value) ||
-			(existing->entry->value && value &&
-			 !strcmp(existing->entry->value, value))) {
-			ret = 0;
-			goto out;
-		}
+		error = 0;
+		goto out;
 	}
 
 	/* No early returns due to sanity checks, let's write it out and refresh */
-
 	if (value) {
 		esc_value = escape_value(value);
-		GITERR_CHECK_ALLOC(esc_value);
+		GIT_ERROR_CHECK_ALLOC(esc_value);
 	}
 
-	if ((ret = config_write(b, name, key, NULL, esc_value)) < 0)
+	if ((error = config_write(b, name, key, NULL, esc_value)) < 0)
 		goto out;
 
-	ret = config_refresh(cfg);
+	error = config_refresh(cfg);
 
 out:
-	refcounted_strmap_free(map);
+	git_config_entries_free(entries);
 	git__free(esc_value);
 	git__free(key);
-	return ret;
+	return error;
 }
 
 /* release the map containing the entry as an equivalent to freeing it */
-static void release_map(git_config_entry *entry)
+static void free_diskfile_entry(git_config_entry *entry)
 {
-	refcounted_strmap *map = (refcounted_strmap *) entry->payload;
-	refcounted_strmap_free(map);
+	git_config_entries *entries = (git_config_entries *) entry->payload;
+	git_config_entries_free(entries);
 }
 
 /*
@@ -524,36 +302,26 @@ static void release_map(git_config_entry *entry)
 static int config_get(git_config_backend *cfg, const char *key, git_config_entry **out)
 {
 	diskfile_header *h = (diskfile_header *)cfg;
-	refcounted_strmap *map;
-	git_strmap *values;
-	khiter_t pos;
-	cvar_t *var;
+	git_config_entries *entries = NULL;
+	git_config_entry *entry;
 	int error = 0;
 
 	if (!h->parent.readonly && ((error = config_refresh(cfg)) < 0))
 		return error;
 
-	if ((map = refcounted_strmap_take(h)) == NULL)
+	if ((entries = diskfile_entries_take(h)) == NULL)
 		return -1;
-	values = map->values;
-
-	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;
+	if ((error = (git_config_entries_get(&entry, entries, key))) < 0) {
+		git_config_entries_free(entries);
+		return error;
 	}
 
-	var = git_strmap_value_at(values, pos);
-	while (var->next)
-		var = var->next;
-
-	*out = var->entry;
-	(*out)->free = release_map;
-	(*out)->payload = map;
+	entry->free = free_diskfile_entry;
+	entry->payload = entries;
+	*out = entry;
 
-	return error;
+	return 0;
 }
 
 static int config_set_multivar(
@@ -571,7 +339,7 @@ static int config_set_multivar(
 
 	result = p_regcomp(&preg, regexp, REG_EXTENDED);
 	if (result != 0) {
-		giterr_set_regex(&preg, result);
+		git_error_set_regex(&preg, result);
 		result = -1;
 		goto out;
 	}
@@ -591,79 +359,62 @@ out:
 
 static int config_delete(git_config_backend *cfg, const char *name)
 {
-	cvar_t *var;
 	diskfile_backend *b = (diskfile_backend *)cfg;
-	refcounted_strmap *map;	git_strmap *values;
-	char *key;
-	int result;
-	khiter_t pos;
-
-	if ((result = git_config__normalize_name(name, &key)) < 0)
-		return result;
-
-	if ((map = refcounted_strmap_take(&b->header)) == NULL)
-		return -1;
-	values = b->header.values->values;
-
-	pos = git_strmap_lookup_index(values, key);
-	git__free(key);
+	git_config_entries *entries = NULL;
+	git_config_entry *entry;
+	char *key = NULL;
+	int error;
 
-	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 = git_config__normalize_name(name, &key)) < 0)
+		goto out;
 
-	var = git_strmap_value_at(values, pos);
-	refcounted_strmap_free(map);
+	if ((entries = diskfile_entries_take(&b->header)) == NULL)
+		goto out;
 
-	if (var->included) {
-		giterr_set(GITERR_CONFIG, "cannot delete included variable");
-		return -1;
+	/* 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;
 	}
 
-	if (var->next != NULL) {
-		giterr_set(GITERR_CONFIG, "cannot delete multivar with a single delete");
-		return -1;
-	}
+	if ((error = config_write(b, name, entry->name, NULL, NULL)) < 0)
+		goto out;
 
-	if ((result = config_write(b, name, var->entry->name, NULL, NULL)) < 0)
-		return result;
+	if ((error =  config_refresh(cfg)) < 0)
+		goto out;
 
-	return config_refresh(cfg);
+out:
+	git_config_entries_free(entries);
+	git__free(key);
+	return error;
 }
 
 static int config_delete_multivar(git_config_backend *cfg, const char *name, const char *regexp)
 {
 	diskfile_backend *b = (diskfile_backend *)cfg;
-	refcounted_strmap *map;
-	git_strmap *values;
-	char *key;
-	regex_t preg;
+	git_config_entries *entries = NULL;
+	git_config_entry *entry = NULL;
+	regex_t preg = { 0 };
+	char *key = NULL;
 	int result;
-	khiter_t pos;
 
 	if ((result = git_config__normalize_name(name, &key)) < 0)
-		return result;
-
-	if ((map = refcounted_strmap_take(&b->header)) == NULL)
-		return -1;
-	values = b->header.values->values;
-
-	pos = git_strmap_lookup_index(values, key);
+		goto out;
 
-	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 ((entries = diskfile_entries_take(&b->header)) == NULL) {
+		result = -1;
+		goto out;
 	}
 
-	refcounted_strmap_free(map);
+	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;
+	}
 
-	result = p_regcomp(&preg, regexp, REG_EXTENDED);
-	if (result != 0) {
-		giterr_set_regex(&preg, result);
+	if ((result = p_regcomp(&preg, regexp, REG_EXTENDED)) != 0) {
+		git_error_set_regex(&preg, result);
 		result = -1;
 		goto out;
 	}
@@ -671,21 +422,16 @@ static int config_delete_multivar(git_config_backend *cfg, const char *name, con
 	if ((result = config_write(b, name, key, &preg, NULL)) < 0)
 		goto out;
 
-	result = config_refresh(cfg);
+	if ((result = config_refresh(cfg)) < 0)
+		goto out;
 
 out:
+	git_config_entries_free(entries);
 	git__free(key);
 	regfree(&preg);
 	return result;
 }
 
-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)
 {
 	diskfile_backend *cfg = (diskfile_backend *) _cfg;
@@ -716,24 +462,24 @@ static int config_unlock(git_config_backend *_cfg, int success)
 	}
 
 	git_filebuf_cleanup(&cfg->locked_buf);
-	git_buf_free(&cfg->locked_content);
+	git_buf_dispose(&cfg->locked_content);
 	cfg->locked = false;
 
 	return error;
 }
 
-int git_config_file__ondisk(git_config_backend **out, const char *path)
+int git_config_backend_from_file(git_config_backend **out, const char *path)
 {
 	diskfile_backend *backend;
 
 	backend = git__calloc(1, sizeof(diskfile_backend));
-	GITERR_CHECK_ALLOC(backend);
+	GIT_ERROR_CHECK_ALLOC(backend);
 
 	backend->header.parent.version = GIT_CONFIG_BACKEND_VERSION;
 	git_mutex_init(&backend->header.values_mutex);
 
 	backend->file.path = git__strdup(path);
-	GITERR_CHECK_ALLOC(backend->file.path);
+	GIT_ERROR_CHECK_ALLOC(backend->file.path);
 	git_array_init(backend->file.includes);
 
 	backend->header.parent.open = config_open;
@@ -812,7 +558,7 @@ static void backend_readonly_free(git_config_backend *_backend)
 	if (backend == NULL)
 		return;
 
-	refcounted_strmap_free(backend->header.values);
+	git_config_entries_free(backend->header.entries);
 	git_mutex_free(&backend->header.values_mutex);
 	git__free(backend);
 }
@@ -822,7 +568,7 @@ static int config_readonly_open(git_config_backend *cfg, git_config_level_t leve
 	diskfile_readonly_backend *b = (diskfile_readonly_backend *) cfg;
 	diskfile_backend *src = b->snapshot_from;
 	diskfile_header *src_header = &src->header;
-	refcounted_strmap *src_map;
+	git_config_entries *entries;
 	int error;
 
 	if (!src_header->parent.readonly && (error = config_refresh(&src_header->parent)) < 0)
@@ -832,24 +578,24 @@ static int config_readonly_open(git_config_backend *cfg, git_config_level_t leve
 	GIT_UNUSED(level);
 	GIT_UNUSED(repo);
 
-	if ((src_map = refcounted_strmap_take(src_header)) == NULL)
+	if ((entries = diskfile_entries_take(src_header)) == NULL)
 		return -1;
-	b->header.values = src_map;
+	b->header.entries = entries;
 
 	return 0;
 }
 
-int git_config_file__snapshot(git_config_backend **out, diskfile_backend *in)
+static int config_snapshot(git_config_backend **out, git_config_backend *in)
 {
 	diskfile_readonly_backend *backend;
 
 	backend = git__calloc(1, sizeof(diskfile_readonly_backend));
-	GITERR_CHECK_ALLOC(backend);
+	GIT_ERROR_CHECK_ALLOC(backend);
 
 	backend->header.parent.version = GIT_CONFIG_BACKEND_VERSION;
 	git_mutex_init(&backend->header.values_mutex);
 
-	backend->snapshot_from = in;
+	backend->snapshot_from = (diskfile_backend *) in;
 
 	backend->header.parent.readonly = 1;
 	backend->header.parent.version = GIT_CONFIG_BACKEND_VERSION;
@@ -904,24 +650,14 @@ static char *escape_value(const char *ptr)
 		ptr++;
 	}
 
-	if (git_buf_oom(&buf)) {
-		git_buf_free(&buf);
+	if (git_buf_oom(&buf))
 		return NULL;
-	}
 
 	return git_buf_detach(&buf);
 }
 
-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)
+	diskfile_parse_state *parse_data, const char *file)
 {
 	struct config_file *include;
 	git_buf path = GIT_BUF_INIT;
@@ -946,11 +682,11 @@ static int parse_include(git_config_parser *reader,
 	git_array_init(include->includes);
 	include->path = git_buf_detach(&path);
 
-	result = config_read(parse_data->values, parse_data->repo,
+	result = config_read(parse_data->entries, parse_data->repo,
 		include, parse_data->level, parse_data->depth+1);
 
 	if (result == GIT_ENOTFOUND) {
-		giterr_clear();
+		git_error_clear();
 		result = 0;
 	}
 
@@ -995,7 +731,7 @@ static int do_match_gitdir(
 	*matches = (error == 0);
 
 out:
-	git_buf_free(&path);
+	git_buf_dispose(&path);
 	return error;
 }
 
@@ -1026,7 +762,7 @@ static const struct {
 };
 
 static int parse_conditional_include(git_config_parser *reader,
-	struct parse_data *parse_data, const char *section, const char *file)
+	diskfile_parse_state *parse_data, const char *section, const char *file)
 {
 	char *condition;
 	size_t i;
@@ -1061,15 +797,16 @@ static int parse_conditional_include(git_config_parser *reader,
 static int read_on_variable(
 	git_config_parser *reader,
 	const char *current_section,
-	char *var_name,
-	char *var_value,
+	const char *var_name,
+	const char *var_value,
 	const char *line,
 	size_t line_len,
 	void *data)
 {
-	struct parse_data *parse_data = (struct parse_data *)data;
+	diskfile_parse_state *parse_data = (diskfile_parse_state *)data;
 	git_buf buf = GIT_BUF_INIT;
-	cvar_t *var;
+	git_config_entry *entry;
+	const char *c;
 	int result = 0;
 
 	GIT_UNUSED(line);
@@ -1083,56 +820,50 @@ 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);
 
-	if (git_buf_oom(&buf)) {
-		git__free(var_value);
-		return -1;
-	}
+	for (c = var_name; *c; c++)
+		git_buf_putc(&buf, git__tolower(*c));
 
-	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);
+	if (git_buf_oom(&buf))
+		return -1;
 
-	var->entry->name = git_buf_detach(&buf);
-	var->entry->value = var_value;
-	var->entry->level = parse_data->level;
-	var->included = !!parse_data->depth;
+	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;
 
-	if ((result = append_entry(parse_data->values, var)) < 0)
+	if ((result = git_config_entries_append(parse_data->entries, entry)) < 0)
 		return result;
 
 	result = 0;
 
 	/* Add or append the new config option */
-	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"))
+	if (!git__strcmp(entry->name, "include.path"))
+		result = parse_include(reader, parse_data, entry->value);
+	else if (!git__prefixcmp(entry->name, "includeif.") &&
+	         !git__suffixcmp(entry->name, ".path"))
 		result = parse_conditional_include(reader, parse_data,
-						   var->entry->name, var->entry->value);
-
+						   entry->name, entry->value);
 
 	return result;
 }
 
 static int config_read(
-	git_strmap *values,
+	git_config_entries *entries,
 	const git_repository *repo,
 	git_config_file *file,
 	git_config_level_t level,
 	int depth)
 {
-	struct parse_data parse_data;
+	diskfile_parse_state parse_data;
 	git_config_parser reader;
 	git_buf contents = GIT_BUF_INIT;
 	int error;
 
 	if (depth >= MAX_INCLUDE_DEPTH) {
-		giterr_set(GITERR_CONFIG, "maximum config include depth reached");
+		git_error_set(GIT_ERROR_CONFIG, "maximum config include depth reached");
 		return -1;
 	}
 
@@ -1154,14 +885,14 @@ static int config_read(
 
 	parse_data.repo = repo;
 	parse_data.file_path = file->path;
-	parse_data.values = values;
+	parse_data.entries = entries;
 	parse_data.level = level;
 	parse_data.depth = depth;
 
 	error = git_config_parse(&reader, NULL, read_on_variable, NULL, NULL, &parse_data);
 
 out:
-	git_buf_free(&contents);
+	git_buf_dispose(&contents);
 	return error;
 }
 
@@ -1180,7 +911,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);
-		GITERR_CHECK_ALLOC(escaped);
+		GIT_ERROR_CHECK_ALLOC(escaped);
 		git_buf_printf(&buf, " \"%s\"", escaped);
 		git__free(escaped);
 	}
@@ -1190,7 +921,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_free(&buf);
+	git_buf_dispose(&buf);
 
 	return result;
 }
@@ -1299,8 +1030,8 @@ static int write_on_section(
 static int write_on_variable(
 	git_config_parser *reader,
 	const char *current_section,
-	char *var_name,
-	char *var_value,
+	const char *var_name,
+	const char *var_value,
 	const char *line,
 	size_t line_len,
 	void *data)
@@ -1329,9 +1060,6 @@ static int write_on_variable(
 	if (has_matched && write_data->preg != NULL)
 		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.
 	 */
@@ -1409,7 +1137,7 @@ static int config_write(diskfile_backend *cfg, const char *orig_key, const char
 		/* 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);
+			git_buf_dispose(&contents);
 			return result;
 		}
 
@@ -1428,12 +1156,12 @@ static int config_write(diskfile_backend *cfg, const char *orig_key, const char
 	ldot = strrchr(key, '.');
 	name = ldot + 1;
 	section = git__strndup(key, ldot - key);
-	GITERR_CHECK_ALLOC(section);
+	GIT_ERROR_CHECK_ALLOC(section);
 
 	ldot = strrchr(orig_key, '.');
 	orig_name = ldot + 1;
 	orig_section = git__strndup(orig_key, ldot - orig_key);
-	GITERR_CHECK_ALLOC(orig_section);
+	GIT_ERROR_CHECK_ALLOC(orig_section);
 
 	write_data.buf = &buf;
 	git_buf_init(&write_data.buffered_comment, 0);
@@ -1454,7 +1182,7 @@ static int config_write(diskfile_backend *cfg, const char *orig_key, const char
 		&write_data);
 	git__free(section);
 	git__free(orig_section);
-	git_buf_free(&write_data.buffered_comment);
+	git_buf_dispose(&write_data.buffered_comment);
 
 	if (result < 0) {
 		git_filebuf_cleanup(&file);
@@ -1464,7 +1192,7 @@ static int config_write(diskfile_backend *cfg, const char *orig_key, const char
 	if (cfg->locked) {
 		size_t len = buf.asize;
 		/* Update our copy with the modified contents */
-		git_buf_free(&cfg->locked_content);
+		git_buf_dispose(&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));
@@ -1472,8 +1200,8 @@ static int config_write(diskfile_backend *cfg, const char *orig_key, const char
 	}
 
 done:
-	git_buf_free(&buf);
-	git_buf_free(&contents);
+	git_buf_dispose(&buf);
+	git_buf_dispose(&contents);
 	git_parse_ctx_clear(&reader.ctx);
 	return result;
 }