rugged 0.27.5 → 0.27.7

data/vendor/libgit2/src/buffer.c

@@ -116,7 +116,7 @@ int git_buf_grow_by(git_buf *buffer, size_t additional_size)
 	return git_buf_try_grow(buffer, newsize, true);
 }
 
-void git_buf_free(git_buf *buf)
+void git_buf_dispose(git_buf *buf)
 {
 	if (!buf) return;
 
@@ -126,6 +126,11 @@ void git_buf_free(git_buf *buf)
 	git_buf_init(buf, 0);
 }
 
+void git_buf_free(git_buf *buf)
+{
+	git_buf_dispose(buf);
+}
+
 void git_buf_sanitize(git_buf *buf)
 {
 	if (buf->ptr == NULL) {
@@ -610,7 +615,7 @@ char *git_buf_detach(git_buf *buf)
 
 int git_buf_attach(git_buf *buf, char *ptr, size_t asize)
 {
-	git_buf_free(buf);
+	git_buf_dispose(buf);
 
 	if (ptr) {
 		buf->ptr = ptr;
@@ -628,7 +633,7 @@ int git_buf_attach(git_buf *buf, char *ptr, size_t asize)
 void git_buf_attach_notowned(git_buf *buf, const char *ptr, size_t size)
 {
 	if (git_buf_is_allocated(buf))
-		git_buf_free(buf);
+		git_buf_dispose(buf);
 
 	if (!size) {
 		git_buf_init(buf, 0);
@@ -949,7 +954,7 @@ int git_buf_quote(git_buf *buf)
 	git_buf_swap(&quoted, buf);
 
 done:
-	git_buf_free(&quoted);
+	git_buf_dispose(&quoted);
 	return error;
 }
 

data/vendor/libgit2/src/buffer.h

@@ -76,7 +76,7 @@ extern char *git_buf_detach(git_buf *buf);
 extern int git_buf_attach(git_buf *buf, char *ptr, size_t asize);
 
 /* Populates a `git_buf` where the contents are not "owned" by the
- * buffer, and calls to `git_buf_free` will not free the given buf.
+ * buffer, and calls to `git_buf_dispose` will not free the given buf.
  */
 extern void git_buf_attach_notowned(
 	git_buf *buf, const char *ptr, size_t size);

data/vendor/libgit2/src/checkout.c

@@ -1604,7 +1604,7 @@ static int blob_content_to_link(
 		st->st_mode = GIT_FILEMODE_LINK;
 	}
 
-	git_buf_free(&linktarget);
+	git_buf_dispose(&linktarget);
 
 	return error;
 }
@@ -2161,13 +2161,13 @@ static int checkout_write_merge(
 done:
 	git_filter_list_free(fl);
 
-	git_buf_free(&out_data);
-	git_buf_free(&our_label);
-	git_buf_free(&their_label);
+	git_buf_dispose(&out_data);
+	git_buf_dispose(&our_label);
+	git_buf_dispose(&their_label);
 
 	git_merge_file_result_free(&result);
-	git_buf_free(&path_workdir);
-	git_buf_free(&path_suffixed);
+	git_buf_dispose(&path_workdir);
+	git_buf_dispose(&path_suffixed);
 
 	return error;
 }
@@ -2347,8 +2347,8 @@ static void checkout_data_clear(checkout_data *data)
 	git__free(data->pfx);
 	data->pfx = NULL;
 
-	git_buf_free(&data->target_path);
-	git_buf_free(&data->tmp);
+	git_buf_dispose(&data->target_path);
+	git_buf_dispose(&data->tmp);
 
 	git_index_free(data->index);
 	data->index = NULL;
@@ -2397,6 +2397,9 @@ static int checkout_data_init(
 				GIT_DIR_MODE, GIT_MKDIR_VERIFY_DIR)) < 0)
 		goto cleanup;
 
+	if ((error = git_repository_index(&data->index, data->repo)) < 0)
+		goto cleanup;
+
 	/* refresh config and index content unless NO_REFRESH is given */
 	if ((data->opts.checkout_strategy & GIT_CHECKOUT_NO_REFRESH) == 0) {
 		git_config *cfg;
@@ -2404,24 +2407,30 @@ static int checkout_data_init(
 		if ((error = git_repository_config__weakptr(&cfg, repo)) < 0)
 			goto cleanup;
 
-		/* Get the repository index and reload it (unless we're checking
-		 * out the index; then it has the changes we're trying to check
-		 * out and those should not be overwritten.)
+		/* Reload the repository index (unless we're checking out the
+		 * index; then it has the changes we're trying to check out
+		 * and those should not be overwritten.)
 		 */
-		if ((error = git_repository_index(&data->index, data->repo)) < 0)
-			goto cleanup;
-
 		if (data->index != git_iterator_index(target)) {
-			if ((error = git_index_read(data->index, true)) < 0)
-				goto cleanup;
-
-			/* cannot checkout if unresolved conflicts exist */
-			if ((data->opts.checkout_strategy & GIT_CHECKOUT_FORCE) == 0 &&
-				git_index_has_conflicts(data->index)) {
-				error = GIT_ECONFLICT;
-				giterr_set(GITERR_CHECKOUT,
-					"unresolved conflicts exist in the index");
-				goto cleanup;
+			if (data->opts.checkout_strategy & GIT_CHECKOUT_FORCE) {
+				/* When forcing, we can blindly re-read the index */
+				if ((error = git_index_read(data->index, false)) < 0)
+					goto cleanup;
+			} else {
+				/*
+				 * When not being forced, we need to check for unresolved
+				 * conflicts and unsaved changes in the index before
+				 * proceeding.
+				 */
+				if (git_index_has_conflicts(data->index)) {
+					error = GIT_ECONFLICT;
+					giterr_set(GITERR_CHECKOUT,
+						"unresolved conflicts exist in the index");
+					goto cleanup;
+				}
+
+				if ((error = git_index_read_safely(data->index)) < 0)
+					goto cleanup;
 			}
 
 			/* clean conflict data in the current index */

data/vendor/libgit2/src/cherrypick.c

@@ -37,7 +37,7 @@ static int write_cherrypick_head(
 	if (error < 0)
 		git_filebuf_cleanup(&file);
 
-	git_buf_free(&file_path);
+	git_buf_dispose(&file_path);
 
 	return error;
 }
@@ -61,7 +61,7 @@ cleanup:
 	if (error < 0)
 		git_filebuf_cleanup(&file);
 
-	git_buf_free(&file_path);
+	git_buf_dispose(&file_path);
 
 	return error;
 }
@@ -216,7 +216,7 @@ done:
 	git_index_free(index);
 	git_commit_free(our_commit);
 	git_reference_free(our_ref);
-	git_buf_free(&their_label);
+	git_buf_dispose(&their_label);
 
 	return error;
 }

data/vendor/libgit2/src/clone.c

@@ -48,7 +48,7 @@ static int create_branch(
 		return error;
 
 	error = git_reference_create(&branch_ref, repo, git_buf_cstr(&refname), target, 0, log_message);
-	git_buf_free(&refname);
+	git_buf_dispose(&refname);
 	git_commit_free(head_obj);
 
 	if (!error)
@@ -87,8 +87,8 @@ static int setup_tracking_config(
 	error = 0;
 
 cleanup:
-	git_buf_free(&remote_key);
-	git_buf_free(&merge_key);
+	git_buf_dispose(&remote_key);
+	git_buf_dispose(&merge_key);
 	return error;
 }
 
@@ -195,8 +195,8 @@ static int update_head_to_remote(
 		reflog_message);
 
 cleanup:
-	git_buf_free(&remote_master_name);
-	git_buf_free(&branch);
+	git_buf_dispose(&remote_master_name);
+	git_buf_dispose(&branch);
 
 	return error;
 }
@@ -225,7 +225,7 @@ static int update_head_to_branch(
 
 cleanup:
 	git_reference_free(remote_ref);
-	git_buf_free(&remote_branch_name);
+	git_buf_dispose(&remote_branch_name);
 	return retcode;
 }
 
@@ -351,7 +351,7 @@ static int clone_into(git_repository *repo, git_remote *_remote, const git_fetch
 
 cleanup:
 	git_remote_free(remote);
-	git_buf_free(&reflog_message);
+	git_buf_dispose(&reflog_message);
 
 	return error;
 }
@@ -378,7 +378,7 @@ int git_clone__should_clone_local(const char *url_or_path, git_clone_local_t loc
 		git_path_isdir(path);
 
 done:
-	git_buf_free(&fromurl);
+	git_buf_dispose(&fromurl);
 	return is_local;
 }
 
@@ -510,7 +510,7 @@ static int clone_local_into(git_repository *repo, git_remote *remote, const git_
 
 	/* Copy .git/objects/ from the source to the target */
 	if ((error = git_repository_open(&src, git_buf_cstr(&src_path))) < 0) {
-		git_buf_free(&src_path);
+		git_buf_dispose(&src_path);
 		return error;
 	}
 
@@ -549,10 +549,10 @@ static int clone_local_into(git_repository *repo, git_remote *remote, const git_
 	error = checkout_branch(repo, remote, co_opts, branch, git_buf_cstr(&reflog_message));
 
 cleanup:
-	git_buf_free(&reflog_message);
-	git_buf_free(&src_path);
-	git_buf_free(&src_odb);
-	git_buf_free(&dst_odb);
+	git_buf_dispose(&reflog_message);
+	git_buf_dispose(&src_path);
+	git_buf_dispose(&src_odb);
+	git_buf_dispose(&dst_odb);
 	git_repository_free(src);
 	return error;
 }

data/vendor/libgit2/src/commit.c

@@ -11,6 +11,7 @@
 #include "git2/object.h"
 #include "git2/repository.h"
 #include "git2/signature.h"
+#include "git2/mailmap.h"
 #include "git2/sys/commit.h"
 
 #include "odb.h"
@@ -74,7 +75,7 @@ static int git_commit__create_buffer_internal(
 	return 0;
 
 on_error:
-	git_buf_free(out);
+	git_buf_dispose(out);
 	return -1;
 }
 
@@ -176,7 +177,7 @@ static int git_commit__create_internal(
 cleanup:
 	git_array_clear(parents);
 	git_reference_free(ref);
-	git_buf_free(&buf);
+	git_buf_dispose(&buf);
 	return error;
 }
 
@@ -886,6 +887,18 @@ int git_commit_create_with_signature(
 		goto cleanup;
 
 cleanup:
-	git_buf_free(&commit);
+	git_buf_dispose(&commit);
 	return error;
 }
+
+int git_commit_committer_with_mailmap(
+	git_signature **out, const git_commit *commit, const git_mailmap *mailmap)
+{
+	return git_mailmap_resolve_signature(out, mailmap, commit->committer);
+}
+
+int git_commit_author_with_mailmap(
+	git_signature **out, const git_commit *commit, const git_mailmap *mailmap)
+{
+	return git_mailmap_resolve_signature(out, mailmap, commit->author);
+}

data/vendor/libgit2/src/common.h

@@ -17,8 +17,10 @@
 /** Declare a function as always inlined. */
 #if defined(_MSC_VER)
 # define GIT_INLINE(type) static __inline type
+#elif defined(__GNUC__)
+# define GIT_INLINE(type) static __inline__ type
 #else
-# define GIT_INLINE(type) static inline type
+# define GIT_INLINE(type) static type
 #endif
 
 /** Support for gcc/clang __has_builtin intrinsic */

data/vendor/libgit2/src/config.c

@@ -1164,7 +1164,7 @@ int git_config_open_default(git_config **out)
 		error = git_config_add_file_ondisk(cfg, buf.ptr,
 			GIT_CONFIG_LEVEL_PROGRAMDATA, NULL, 0);
 
-	git_buf_free(&buf);
+	git_buf_dispose(&buf);
 
 	if (error) {
 		git_config_free(cfg);
@@ -1478,8 +1478,8 @@ int git_config_rename_section(
 		config, git_buf_cstr(&pattern), rename_config_entries_cb, &data);
 
 cleanup:
-	git_buf_free(&pattern);
-	git_buf_free(&replace);
+	git_buf_dispose(&pattern);
+	git_buf_dispose(&replace);
 
 	return error;
 }

data/vendor/libgit2/src/config_file.c

@@ -23,69 +23,30 @@
 #include <sys/types.h>
 #include <regex.h>
 
-typedef struct cvar_t {
-	struct cvar_t *next;
+typedef struct config_entry_list {
+	struct config_entry_list *next;
 	git_config_entry *entry;
-	bool included; /* whether this is part of [include] */
-} cvar_t;
+} config_entry_list;
 
 typedef struct git_config_file_iter {
 	git_config_iterator parent;
-	git_strmap_iter iter;
-	cvar_t* next_var;
+	config_entry_list *head;
 } 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;
+	git_strmap *map;
+	config_entry_list *list;
+} diskfile_entries;
 
 typedef struct {
 	git_config_backend parent;
 	/* mutex to coordinate accessing the values */
 	git_mutex values_mutex;
-	refcounted_strmap *values;
+	diskfile_entries *entries;
 	const git_repository *repo;
 	git_config_level_t level;
 } diskfile_header;
@@ -108,7 +69,15 @@ 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;
+	diskfile_entries *entries;
+	git_config_level_t level;
+	unsigned int depth;
+} diskfile_parse_state;
+
+static int config_read(diskfile_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);
 
@@ -121,15 +90,20 @@ static int config_error_readonly(void)
 	return -1;
 }
 
-static void cvar_free(cvar_t *var)
+static void config_entry_list_free(config_entry_list *list)
 {
-	if (var == NULL)
-		return;
+	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);
 
-	git__free((char*)var->entry->name);
-	git__free((char *)var->entry->value);
-	git__free(var->entry);
-	git__free(var);
+		list = next;
+	};
 }
 
 int git_config_file_normalize_section(char *start, char *end)
@@ -155,57 +129,70 @@ int git_config_file_normalize_section(char *start, char *end)
 	return 0;
 }
 
+static void config_entry_list_append(config_entry_list **list, config_entry_list *entry)
+{
+	config_entry_list *head = *list;
+
+	if (head) {
+		while (head->next != NULL)
+			head = head->next;
+		head->next = entry;
+	} else {
+		*list = entry;
+	}
+}
+
 /* Add or append the new config option */
-static int append_entry(git_strmap *values, cvar_t *var)
+static int diskfile_entries_append(diskfile_entries *entries, git_config_entry *entry)
 {
 	git_strmap_iter pos;
-	cvar_t *existing;
+	config_entry_list *existing, *var;
 	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);
+	var = git__calloc(1, sizeof(config_entry_list));
+	GITERR_CHECK_ALLOC(var);
+	var->entry = entry;
+
+	pos = git_strmap_lookup_index(entries->map, entry->name);
+	if (!git_strmap_valid_index(entries->map, pos)) {
+		git_strmap_insert(entries->map, entry->name, var, &error);
+
+		if (error > 0)
+			error = 0;
 	} else {
-		existing = git_strmap_value_at(values, pos);
-		while (existing->next != NULL) {
-			existing = existing->next;
-		}
-		existing->next = var;
+		existing = git_strmap_value_at(entries->map, pos);
+		config_entry_list_append(&existing, var);
 	}
 
-	if (error > 0)
-		error = 0;
+	var = git__calloc(1, sizeof(config_entry_list));
+	GITERR_CHECK_ALLOC(var);
+	var->entry = entry;
+	config_entry_list_append(&entries->list, var);
 
 	return error;
 }
 
-static void free_vars(git_strmap *values)
+static void diskfile_entries_free(diskfile_entries *entries)
 {
-	cvar_t *var = NULL;
+	config_entry_list *list = NULL, *next;
 
-	if (values == NULL)
+	if (!entries)
 		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)
+	if (git_atomic_dec(&entries->refcount) != 0)
 		return;
 
-	if (git_atomic_dec(&map->refcount) != 0)
-		return;
+	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;
+	}
 
-	free_vars(map->values);
-	git__free(map);
+	git__free(entries);
 }
 
 /**
@@ -213,37 +200,37 @@ static void refcounted_strmap_free(refcounted_strmap *map)
  * 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 diskfile_entries *diskfile_entries_take(diskfile_header *h)
 {
-	refcounted_strmap *map;
+	diskfile_entries *entries;
 
 	if (git_mutex_lock(&h->values_mutex) < 0) {
 	    giterr_set(GITERR_OS, "failed to lock config backend");
 	    return NULL;
 	}
 
-	map = h->values;
-	git_atomic_inc(&map->refcount);
+	entries = h->entries;
+	git_atomic_inc(&entries->refcount);
 
 	git_mutex_unlock(&h->values_mutex);
 
-	return map;
+	return entries;
 }
 
-static int refcounted_strmap_alloc(refcounted_strmap **out)
+static int diskfile_entries_alloc(diskfile_entries **out)
 {
-	refcounted_strmap *map;
+	diskfile_entries *entries;
 	int error;
 
-	map = git__calloc(1, sizeof(refcounted_strmap));
-	GITERR_CHECK_ALLOC(map);
+	entries = git__calloc(1, sizeof(diskfile_entries));
+	GITERR_CHECK_ALLOC(entries);
 
-	git_atomic_set(&map->refcount, 1);
+	git_atomic_set(&entries->refcount, 1);
 
-	if ((error = git_strmap_alloc(&map->values)) < 0)
-		git__free(map);
+	if ((error = git_strmap_alloc(&entries->map)) < 0)
+		git__free(entries);
 	else
-		*out = map;
+		*out = entries;
 
 	return error;
 }
@@ -272,15 +259,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 = diskfile_entries_alloc(&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) {
+		diskfile_entries_free(b->header.entries);
+		b->header.entries = NULL;
 	}
 
 	return res;
@@ -313,7 +300,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 +308,7 @@ out:
 static int config_refresh(git_config_backend *cfg)
 {
 	diskfile_backend *b = (diskfile_backend *)cfg;
-	refcounted_strmap *values = NULL, *tmp;
+	diskfile_entries *entries = NULL, *tmp;
 	git_config_file *include;
 	int error, modified;
 	uint32_t i;
@@ -336,7 +323,7 @@ static int config_refresh(git_config_backend *cfg)
 	if (!modified)
 		return 0;
 
-	if ((error = refcounted_strmap_alloc(&values)) < 0)
+	if ((error = diskfile_entries_alloc(&entries)) < 0)
 		goto out;
 
 	/* Reparse the current configuration */
@@ -345,7 +332,7 @@ 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) {
@@ -353,14 +340,14 @@ static int config_refresh(git_config_backend *cfg)
 		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);
+	diskfile_entries_free(entries);
 
 	return (error == GIT_ENOTFOUND) ? 0 : error;
 }
@@ -373,7 +360,7 @@ static void backend_free(git_config_backend *_backend)
 		return;
 
 	config_file_clear(&backend->file);
-	refcounted_strmap_free(backend->header.values);
+	diskfile_entries_free(backend->header.entries);
 	git_mutex_free(&backend->header.values_mutex);
 	git__free(backend);
 }
@@ -390,24 +377,12 @@ static int config_iterator_next(
 	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;
-	}
+	if (!it->head)
+		return GIT_ITEROVER;
 
-	*entry = var->entry;
-	it->next_var = CVAR_LIST_NEXT(var);
+	*entry = it->head->entry;
+	it->head = it->head->next;
 
 	return 0;
 }
@@ -433,15 +408,11 @@ static int config_iterator_new(
 
 	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->head = h->entries->list;
 	it->parent.next = config_iterator_next;
 	it->parent.free = config_iterator_free;
+
 	*iter = (git_config_iterator *) it;
 
 	return 0;
@@ -450,8 +421,8 @@ static int config_iterator_new(
 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;
+	diskfile_entries *entries;
+	git_strmap *entry_map;
 	char *key, *esc_value = NULL;
 	khiter_t pos;
 	int rval, ret;
@@ -459,17 +430,17 @@ static int config_set(git_config_backend *cfg, const char *name, const char *val
 	if ((rval = git_config__normalize_name(name, &key)) < 0)
 		return rval;
 
-	if ((map = refcounted_strmap_take(&b->header)) == NULL)
+	if ((entries = diskfile_entries_take(&b->header)) == NULL)
 		return -1;
-	values = map->values;
+	entry_map = entries->map;
 
 	/*
 	 * 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);
+	pos = git_strmap_lookup_index(entry_map, key);
+	if (git_strmap_valid_index(entry_map, pos)) {
+		config_entry_list *existing = git_strmap_value_at(entry_map, pos);
 
 		if (existing->next != NULL) {
 			giterr_set(GITERR_CONFIG, "multivar incompatible with simple set");
@@ -477,7 +448,7 @@ static int config_set(git_config_backend *cfg, const char *name, const char *val
 			goto out;
 		}
 
-		if (existing->included) {
+		if (existing->entry->include_depth) {
 			giterr_set(GITERR_CONFIG, "modifying included variable is not supported");
 			ret = -1;
 			goto out;
@@ -505,17 +476,17 @@ static int config_set(git_config_backend *cfg, const char *name, const char *val
 	ret = config_refresh(cfg);
 
 out:
-	refcounted_strmap_free(map);
+	diskfile_entries_free(entries);
 	git__free(esc_value);
 	git__free(key);
 	return ret;
 }
 
 /* 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);
+	diskfile_entries *map = (diskfile_entries *) entry->payload;
+	diskfile_entries_free(map);
 }
 
 /*
@@ -524,34 +495,34 @@ 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;
+	diskfile_entries *entries;
+	git_strmap *entry_map;
 	khiter_t pos;
-	cvar_t *var;
+	config_entry_list *var;
 	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;
+	entry_map = entries->map;
 
-	pos = git_strmap_lookup_index(values, key);
+	pos = git_strmap_lookup_index(entry_map, key);
 
 	/* no error message; the config system will write one */
-	if (!git_strmap_valid_index(values, pos)) {
-		refcounted_strmap_free(map);
+	if (!git_strmap_valid_index(entry_map, pos)) {
+		diskfile_entries_free(entries);
 		return GIT_ENOTFOUND;
 	}
 
-	var = git_strmap_value_at(values, pos);
+	var = git_strmap_value_at(entry_map, pos);
 	while (var->next)
 		var = var->next;
 
 	*out = var->entry;
-	(*out)->free = release_map;
-	(*out)->payload = map;
+	(*out)->free = free_diskfile_entry;
+	(*out)->payload = entries;
 
 	return error;
 }
@@ -591,9 +562,10 @@ out:
 
 static int config_delete(git_config_backend *cfg, const char *name)
 {
-	cvar_t *var;
+	config_entry_list *var;
 	diskfile_backend *b = (diskfile_backend *)cfg;
-	refcounted_strmap *map;	git_strmap *values;
+	diskfile_entries *map;
+	git_strmap *entry_map;
 	char *key;
 	int result;
 	khiter_t pos;
@@ -601,23 +573,23 @@ static int config_delete(git_config_backend *cfg, const char *name)
 	if ((result = git_config__normalize_name(name, &key)) < 0)
 		return result;
 
-	if ((map = refcounted_strmap_take(&b->header)) == NULL)
+	if ((map = diskfile_entries_take(&b->header)) == NULL)
 		return -1;
-	values = b->header.values->values;
+	entry_map = b->header.entries->map;
 
-	pos = git_strmap_lookup_index(values, key);
+	pos = git_strmap_lookup_index(entry_map, key);
 	git__free(key);
 
-	if (!git_strmap_valid_index(values, pos)) {
-		refcounted_strmap_free(map);
+	if (!git_strmap_valid_index(entry_map, pos)) {
+		diskfile_entries_free(map);
 		giterr_set(GITERR_CONFIG, "could not find key '%s' to delete", name);
 		return GIT_ENOTFOUND;
 	}
 
-	var = git_strmap_value_at(values, pos);
-	refcounted_strmap_free(map);
+	var = git_strmap_value_at(entry_map, pos);
+	diskfile_entries_free(map);
 
-	if (var->included) {
+	if (var->entry->include_depth) {
 		giterr_set(GITERR_CONFIG, "cannot delete included variable");
 		return -1;
 	}
@@ -636,8 +608,8 @@ static int config_delete(git_config_backend *cfg, const char *name)
 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;
+	diskfile_entries *map;
+	git_strmap *entry_map;
 	char *key;
 	regex_t preg;
 	int result;
@@ -646,20 +618,20 @@ static int config_delete_multivar(git_config_backend *cfg, const char *name, con
 	if ((result = git_config__normalize_name(name, &key)) < 0)
 		return result;
 
-	if ((map = refcounted_strmap_take(&b->header)) == NULL)
+	if ((map = diskfile_entries_take(&b->header)) == NULL)
 		return -1;
-	values = b->header.values->values;
+	entry_map = b->header.entries->map;
 
-	pos = git_strmap_lookup_index(values, key);
+	pos = git_strmap_lookup_index(entry_map, key);
 
-	if (!git_strmap_valid_index(values, pos)) {
-		refcounted_strmap_free(map);
+	if (!git_strmap_valid_index(entry_map, pos)) {
+		diskfile_entries_free(map);
 		git__free(key);
 		giterr_set(GITERR_CONFIG, "could not find key '%s' to delete", name);
 		return GIT_ENOTFOUND;
 	}
 
-	refcounted_strmap_free(map);
+	diskfile_entries_free(map);
 
 	result = p_regcomp(&preg, regexp, REG_EXTENDED);
 	if (result != 0) {
@@ -716,7 +688,7 @@ 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;
@@ -812,7 +784,7 @@ static void backend_readonly_free(git_config_backend *_backend)
 	if (backend == NULL)
 		return;
 
-	refcounted_strmap_free(backend->header.values);
+	diskfile_entries_free(backend->header.entries);
 	git_mutex_free(&backend->header.values_mutex);
 	git__free(backend);
 }
@@ -822,7 +794,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;
+	diskfile_entries *entries;
 	int error;
 
 	if (!src_header->parent.readonly && (error = config_refresh(&src_header->parent)) < 0)
@@ -832,9 +804,9 @@ 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;
 }
@@ -904,33 +876,20 @@ 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;
 	char *dir;
 	int result;
 
-	if (!file)
-		return 0;
-
 	if ((result = git_path_dirname_r(&path, reader->file->path)) < 0)
 		return result;
 
@@ -946,7 +905,7 @@ 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) {
@@ -995,7 +954,7 @@ static int do_match_gitdir(
 	*matches = (error == 0);
 
 out:
-	git_buf_free(&path);
+	git_buf_dispose(&path);
 	return error;
 }
 
@@ -1026,13 +985,13 @@ 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;
 	int error = 0, matches;
 
-	if (!parse_data->repo || !file)
+	if (!parse_data->repo)
 		return 0;
 
 	condition = git__substrdup(section + strlen("includeIf."),
@@ -1061,64 +1020,60 @@ 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);
 	GIT_UNUSED(line_len);
 
-	git__strtolower(var_name);
-	git_buf_printf(&buf, "%s.%s", current_section, var_name);
-	git__free(var_name);
+	git_buf_puts(&buf, current_section);
+	git_buf_putc(&buf, '.');
+	for (c = var_name; *c; c++)
+		git_buf_putc(&buf, git__tolower(*c));
 
-	if (git_buf_oom(&buf)) {
-		git__free(var_value);
+	if (git_buf_oom(&buf))
 		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));
+	GITERR_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 = append_entry(parse_data->values, var)) < 0)
+	if ((result = diskfile_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,
+	diskfile_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;
@@ -1146,14 +1101,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;
 }
 
@@ -1182,7 +1137,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;
 }
@@ -1291,8 +1246,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)
@@ -1321,9 +1276,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.
 	 */
@@ -1401,7 +1353,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;
 		}
 
@@ -1446,7 +1398,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);
@@ -1456,7 +1408,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));
@@ -1464,8 +1416,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;
 }