rugged 0.28.4 → 0.28.4.1

data/vendor/libgit2/src/config.c

@@ -7,15 +7,13 @@
 
 #include "config.h"
 
+#include "sysdir.h"
 #include "git2/config.h"
 #include "git2/sys/config.h"
-
+#include "vector.h"
 #include "buf_text.h"
 #include "config_backend.h"
-#include "regexp.h"
-#include "sysdir.h"
 #include "transaction.h"
-#include "vector.h"
 #if GIT_WIN32
 # include <windows.h>
 #endif
@@ -347,7 +345,7 @@ typedef struct {
 	git_config_iterator parent;
 	git_config_iterator *current;
 	const git_config *cfg;
-	git_regexp regex;
+	regex_t regex;
 	size_t i;
 } all_iter;
 
@@ -425,7 +423,7 @@ static int all_iter_glob_next(git_config_entry **entry, git_config_iterator *_it
 	 */
 	while ((error = all_iter_next(entry, _iter)) == 0) {
 		/* skip non-matching keys if regexp was provided */
-		if (git_regexp_match(&iter->regex, (*entry)->name) != 0)
+		if (regexec(&iter->regex, (*entry)->name, 0, NULL, 0) != 0)
 			continue;
 
 		/* and simply return if we like the entry's name */
@@ -449,7 +447,7 @@ static void all_iter_glob_free(git_config_iterator *_iter)
 {
 	all_iter *iter = (all_iter *) _iter;
 
-	git_regexp_dispose(&iter->regex);
+	regfree(&iter->regex);
 	all_iter_free(_iter);
 }
 
@@ -482,7 +480,8 @@ int git_config_iterator_glob_new(git_config_iterator **out, const git_config *cf
 	iter = git__calloc(1, sizeof(all_iter));
 	GIT_ERROR_CHECK_ALLOC(iter);
 
-	if ((result = git_regexp_compile(&iter->regex, regexp, 0)) < 0) {
+	if ((result = p_regcomp(&iter->regex, regexp, REG_EXTENDED)) != 0) {
+		git_error_set_regex(&iter->regex, result);
 		git__free(iter);
 		return -1;
 	}
@@ -511,13 +510,18 @@ int git_config_backend_foreach_match(
 {
 	git_config_entry *entry;
 	git_config_iterator* iter;
-	git_regexp regex;
+	regex_t regex;
 	int error = 0;
 
 	assert(backend && cb);
 
-	if (regexp && git_regexp_compile(&regex, regexp, 0) < 0)
-		return -1;
+	if (regexp != NULL) {
+		if ((error = p_regcomp(&regex, regexp, REG_EXTENDED)) != 0) {
+			git_error_set_regex(&regex, error);
+			regfree(&regex);
+			return -1;
+		}
+	}
 
 	if ((error = backend->iterator(&iter, backend)) < 0) {
 		iter = NULL;
@@ -526,7 +530,7 @@ int git_config_backend_foreach_match(
 
 	while (!(iter->next(&entry, iter) < 0)) {
 		/* skip non-matching keys if regexp was provided */
-		if (regexp && git_regexp_match(&regex, entry->name) != 0)
+		if (regexp && regexec(&regex, entry->name, 0, NULL, 0) != 0)
 			continue;
 
 		/* abort iterator on non-zero return value */
@@ -537,7 +541,7 @@ int git_config_backend_foreach_match(
 	}
 
 	if (regexp != NULL)
-		git_regexp_dispose(&regex);
+		regfree(&regex);
 
 	iter->free(iter);
 
@@ -657,7 +661,7 @@ int git_config_set_string(git_config *cfg, const char *name, const char *value)
 	error = backend->set(backend, name, value);
 
 	if (!error && GIT_REFCOUNT_OWNER(cfg) != NULL)
-		git_repository__configmap_lookup_cache_clear(GIT_REFCOUNT_OWNER(cfg));
+		git_repository__cvar_cache_clear(GIT_REFCOUNT_OWNER(cfg));
 
 	return error;
 }
@@ -773,7 +777,7 @@ int git_config_get_mapped(
 	int *out,
 	const git_config *cfg,
 	const char *name,
-	const git_configmap *maps,
+	const git_cvar_map *maps,
 	size_t map_n)
 {
 	git_config_entry *entry;
@@ -977,7 +981,7 @@ typedef struct {
 	git_config_iterator parent;
 	git_config_iterator *iter;
 	char *name;
-	git_regexp regex;
+	regex_t regex;
 	int have_regex;
 } multivar_iter;
 
@@ -993,7 +997,7 @@ static int multivar_iter_next(git_config_entry **entry, git_config_iterator *_it
 		if (!iter->have_regex)
 			return 0;
 
-		if (git_regexp_match(&iter->regex, (*entry)->value) == 0)
+		if (regexec(&iter->regex, (*entry)->value, 0, NULL, 0) == 0)
 			return 0;
 	}
 
@@ -1008,7 +1012,7 @@ void multivar_iter_free(git_config_iterator *_iter)
 
 	git__free(iter->name);
 	if (iter->have_regex)
-		git_regexp_dispose(&iter->regex);
+		regfree(&iter->regex);
 	git__free(iter);
 }
 
@@ -1028,8 +1032,13 @@ int git_config_multivar_iterator_new(git_config_iterator **out, const git_config
 		goto on_error;
 
 	if (regexp != NULL) {
-		if ((error = git_regexp_compile(&iter->regex, regexp, 0)) < 0)
+		error = p_regcomp(&iter->regex, regexp, REG_EXTENDED);
+		if (error != 0) {
+			git_error_set_regex(&iter->regex, error);
+			error = -1;
+			regfree(&iter->regex);
 			goto on_error;
+		}
 
 		iter->have_regex = 1;
 	}
@@ -1221,7 +1230,7 @@ int git_config_unlock(git_config *cfg, int commit)
 
 int git_config_lookup_map_value(
 	int *out,
-	const git_configmap *maps,
+	const git_cvar_map *maps,
 	size_t map_n,
 	const char *value)
 {
@@ -1231,27 +1240,27 @@ int git_config_lookup_map_value(
 		goto fail_parse;
 
 	for (i = 0; i < map_n; ++i) {
-		const git_configmap *m = maps + i;
+		const git_cvar_map *m = maps + i;
 
-		switch (m->type) {
-		case GIT_CONFIGMAP_FALSE:
-		case GIT_CONFIGMAP_TRUE: {
+		switch (m->cvar_type) {
+		case GIT_CVAR_FALSE:
+		case GIT_CVAR_TRUE: {
 			int bool_val;
 
 			if (git__parse_bool(&bool_val, value) == 0 &&
-				bool_val == (int)m->type) {
+				bool_val == (int)m->cvar_type) {
 				*out = m->map_value;
 				return 0;
 			}
 			break;
 		}
 
-		case GIT_CONFIGMAP_INT32:
+		case GIT_CVAR_INT32:
 			if (git_config_parse_int32(out, value) == 0)
 				return 0;
 			break;
 
-		case GIT_CONFIGMAP_STRING:
+		case GIT_CVAR_STRING:
 			if (strcasecmp(value, m->str_match) == 0) {
 				*out = m->map_value;
 				return 0;
@@ -1265,18 +1274,18 @@ fail_parse:
 	return -1;
 }
 
-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)
 {
 	size_t i;
 
 	for (i = 0; i < map_n; i++) {
-		const git_configmap *m = &maps[i];
+		const git_cvar_map *m = &maps[i];
 
 		if (m->map_value != enum_val)
 			continue;
 
-		*type_out = m->type;
+		*type_out = m->cvar_type;
 		*str_out = m->str_match;
 		return 0;
 	}

data/vendor/libgit2/src/config.h

@@ -66,19 +66,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_backend.h

@@ -25,18 +25,6 @@
  */
 extern int git_config_backend_from_file(git_config_backend **out, const char *path);
 
-/**
- * Create a readonly configuration file backend from another backend
- *
- * This copies the complete contents of the source backend to the
- * new backend. The new backend will be completely read-only and
- * cannot be modified.
- *
- * @param out the new snapshotted backend
- * @param source the backend to copy
- */
-extern int git_config_backend_snapshot(git_config_backend **out, git_config_backend *source);
-
 /**
  * Create an in-memory configuration file backend
  *

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,55 @@ 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_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}
 };
 
-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_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
  */
-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", _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 },
 };
 
-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 +109,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_entries.c

@@ -11,7 +11,6 @@ typedef struct config_entry_list {
 	struct config_entry_list *next;
 	struct config_entry_list *last;
 	git_config_entry *entry;
-	bool first;
 } config_entry_list;
 
 typedef struct config_entries_iterator {
@@ -26,6 +25,31 @@ struct git_config_entries {
 	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;
@@ -35,7 +59,7 @@ int git_config_entries_new(git_config_entries **out)
 	GIT_ERROR_CHECK_ALLOC(entries);
 	GIT_REFCOUNT_INC(entries);
 
-	if ((error = git_strmap_new(&entries->map)) < 0)
+	if ((error = git_strmap_alloc(&entries->map)) < 0)
 		git__free(entries);
 	else
 		*out = entries;
@@ -43,36 +67,6 @@ int git_config_entries_new(git_config_entries **out)
 	return error;
 }
 
-int git_config_entries_dup_entry(git_config_entries *entries, const git_config_entry *entry)
-{
-	git_config_entry *duplicated;
-	int error;
-
-	duplicated = git__calloc(1, sizeof(git_config_entry));
-	GIT_ERROR_CHECK_ALLOC(duplicated);
-
-	duplicated->name = git__strdup(entry->name);
-	GIT_ERROR_CHECK_ALLOC(duplicated->name);
-
-	if (entry->value) {
-		duplicated->value = git__strdup(entry->value);
-		GIT_ERROR_CHECK_ALLOC(duplicated->value);
-	}
-	duplicated->level = entry->level;
-	duplicated->include_depth = entry->include_depth;
-
-	if ((error = git_config_entries_append(entries, duplicated)) < 0)
-		goto out;
-
-out:
-	if (error && duplicated) {
-		git__free((char *) duplicated->name);
-		git__free((char *) duplicated->value);
-		git__free(duplicated);
-	}
-	return error;
-}
-
 int git_config_entries_dup(git_config_entries **out, git_config_entries *entries)
 {
 	git_config_entries *result = NULL;
@@ -82,9 +76,22 @@ int git_config_entries_dup(git_config_entries **out, git_config_entries *entries
 	if ((error = git_config_entries_new(&result)) < 0)
 		goto out;
 
-	for (head = entries->list; head; head = head->next)
-		if ((git_config_entries_dup_entry(result, head->entry)) < 0)
+	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;
@@ -103,15 +110,12 @@ 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;
-		if (list->first)
-			git__free((char *) list->entry->name);
-		git__free((char *) list->entry->value);
-		git__free(list->entry);
 		git__free(list);
 		list = next;
 	}
@@ -127,33 +131,55 @@ void git_config_entries_free(git_config_entries *entries)
 
 int git_config_entries_append(git_config_entries *entries, git_config_entry *entry)
 {
-	config_entry_list *existing, *head;
-
-	head = git__calloc(1, sizeof(config_entry_list));
-	GIT_ERROR_CHECK_ALLOC(head);
-	head->entry = entry;
-
-	/*
-	 * This is a micro-optimization for configuration files
-	 * with a lot of same keys. As for multivars the entry's
-	 * key will be the same for all entries, we can just free
-	 * all except the first entry's name and just re-use it.
-	 */
-	if ((existing = git_strmap_get(entries->map, entry->name)) != NULL) {
-		git__free((char *) entry->name);
-		entry->name = existing->entry->name;
+	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 {
-		head->first = 1;
+		existing = git_strmap_value_at(entries->map, pos);
+		config_entry_list_append(&existing, var);
 	}
 
-	if (entries->list)
-		entries->list->last->next = head;
-	else
-		entries->list = head;
-	entries->list->last = head;
+	var = git__calloc(1, sizeof(config_entry_list));
+	GIT_ERROR_CHECK_ALLOC(var);
+	var->entry = entry;
+	config_entry_list_append(&entries->list, var);
 
-	if (git_strmap_set(entries->map, entry->name, head) < 0)
-		return -1;
+	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;
 }
@@ -161,20 +187,24 @@ int git_config_entries_append(git_config_entries *entries, git_config_entry *ent
 int git_config_entries_get(git_config_entry **out, git_config_entries *entries, const char *key)
 {
 	config_entry_list *entry;
-	if ((entry = git_strmap_get(entries->map, key)) == NULL)
-		return GIT_ENOTFOUND;
-	*out = entry->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 ((entry = git_strmap_get(entries->map, key)) == NULL)
-		return GIT_ENOTFOUND;
+	if ((error = config_entry_get(&entry, entries, key)) < 0)
+		return error;
 
-	if (!entry->first) {
+	if (entry->next != NULL) {
 		git_error_set(GIT_ERROR_CONFIG, "entry is not unique due to being a multivar");
 		return -1;
 	}
@@ -189,14 +219,14 @@ int git_config_entries_get_unique(git_config_entry **out, git_config_entries *en
 	return 0;
 }
 
-static void config_iterator_free(git_config_iterator *iter)
+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);
 }
 
-static int config_iterator_next(
+int config_iterator_next(
 	git_config_entry **entry,
 	git_config_iterator *iter)
 {