rugged 1.3.1 → 1.9.0

data/vendor/libgit2/src/{config_file.c → libgit2/config_file.c}

@@ -11,21 +11,24 @@
 #include "git2/sys/config.h"
 
 #include "array.h"
-#include "buffer.h"
+#include "str.h"
 #include "config_backend.h"
-#include "config_entries.h"
+#include "config_list.h"
 #include "config_parse.h"
 #include "filebuf.h"
 #include "regexp.h"
 #include "sysdir.h"
 #include "wildmatch.h"
+#include "hash.h"
 
 /* Max depth for [include] directives */
 #define MAX_INCLUDE_DEPTH 10
 
+#define CONFIG_FILE_TYPE "file"
+
 typedef struct config_file {
 	git_futils_filestamp stamp;
-	git_oid checksum;
+	unsigned char checksum[GIT_HASH_SHA256_SIZE];
 	char *path;
 	git_array_t(struct config_file) includes;
 } config_file;
@@ -33,7 +36,7 @@ typedef struct config_file {
 typedef struct {
 	git_config_backend parent;
 	git_mutex values_mutex;
-	git_config_entries *entries;
+	git_config_list *config_list;
 	const git_repository *repo;
 	git_config_level_t level;
 
@@ -41,7 +44,7 @@ typedef struct {
 
 	bool locked;
 	git_filebuf locked_buf;
-	git_buf locked_content;
+	git_str locked_content;
 
 	config_file file;
 } config_file_backend;
@@ -49,13 +52,13 @@ typedef struct {
 typedef struct {
 	const git_repository *repo;
 	config_file *file;
-	git_config_entries *entries;
+	git_config_list *config_list;
 	git_config_level_t level;
 	unsigned int depth;
 } config_file_parse_data;
 
-static int config_file_read(git_config_entries *entries, const git_repository *repo, config_file *file, git_config_level_t level, int depth);
-static int config_file_read_buffer(git_config_entries *entries, const git_repository *repo, config_file *file, git_config_level_t level, int depth, const char *buf, size_t buflen);
+static int config_file_read(git_config_list *config_list, const git_repository *repo, config_file *file, git_config_level_t level, int depth);
+static int config_file_read_buffer(git_config_list *config_list, const git_repository *repo, config_file *file, git_config_level_t level, int depth, const char *buf, size_t buflen);
 static int config_file_write(config_file_backend *cfg, const char *orig_key, const char *key, const git_regexp *preg, const char *value);
 static char *escape_value(const char *ptr);
 
@@ -64,7 +67,7 @@ static char *escape_value(const char *ptr);
  * refcount. This is its own function to make sure we use the mutex to
  * avoid the map pointer from changing under us.
  */
-static int config_file_entries_take(git_config_entries **out, config_file_backend *b)
+static int config_file_take_list(git_config_list **out, config_file_backend *b)
 {
 	int error;
 
@@ -73,8 +76,8 @@ static int config_file_entries_take(git_config_entries **out, config_file_backen
 		return error;
 	}
 
-	git_config_entries_incref(b->entries);
-	*out = b->entries;
+	git_config_list_incref(b->config_list);
+	*out = b->config_list;
 
 	git_mutex_unlock(&b->values_mutex);
 
@@ -105,10 +108,10 @@ static int config_file_open(git_config_backend *cfg, git_config_level_t level, c
 	b->level = level;
 	b->repo = repo;
 
-	if ((res = git_config_entries_new(&b->entries)) < 0)
+	if ((res = git_config_list_new(&b->config_list)) < 0)
 		return res;
 
-	if (!git_path_exists(b->file.path))
+	if (!git_fs_path_exists(b->file.path))
 		return 0;
 
 	/*
@@ -120,9 +123,9 @@ static int config_file_open(git_config_backend *cfg, git_config_level_t level, c
 	if (p_access(b->file.path, R_OK) < 0)
 		return GIT_ENOTFOUND;
 
-	if (res < 0 || (res = config_file_read(b->entries, repo, &b->file, level, 0)) < 0) {
-		git_config_entries_free(b->entries);
-		b->entries = NULL;
+	if (res < 0 || (res = config_file_read(b->config_list, repo, &b->file, level, 0)) < 0) {
+		git_config_list_free(b->config_list);
+		b->config_list = NULL;
 	}
 
 	return res;
@@ -131,8 +134,8 @@ static int config_file_open(git_config_backend *cfg, git_config_level_t level, c
 static int config_file_is_modified(int *modified, config_file *file)
 {
 	config_file *include;
-	git_buf buf = GIT_BUF_INIT;
-	git_oid hash;
+	git_str buf = GIT_STR_INIT;
+	unsigned char checksum[GIT_HASH_SHA256_SIZE];
 	uint32_t i;
 	int error = 0;
 
@@ -144,10 +147,10 @@ static int config_file_is_modified(int *modified, config_file *file)
 	if ((error = git_futils_readbuffer(&buf, file->path)) < 0)
 		goto out;
 
-	if ((error = git_hash_buf(&hash, buf.ptr, buf.size)) < 0)
+	if ((error = git_hash_buf(checksum, buf.ptr, buf.size, GIT_HASH_ALGORITHM_SHA256)) < 0)
 		goto out;
 
-	if (!git_oid_equal(&hash, &file->checksum)) {
+	if (memcmp(checksum, file->checksum, GIT_HASH_SHA256_SIZE) != 0) {
 		*modified = 1;
 		goto out;
 	}
@@ -159,7 +162,7 @@ check_includes:
 	}
 
 out:
-	git_buf_dispose(&buf);
+	git_str_dispose(&buf);
 
 	return error;
 }
@@ -174,10 +177,10 @@ static void config_file_clear_includes(config_file_backend *cfg)
 	git_array_clear(cfg->file.includes);
 }
 
-static int config_file_set_entries(git_config_backend *cfg, git_config_entries *entries)
+static int config_file_set_entries(git_config_backend *cfg, git_config_list *config_list)
 {
 	config_file_backend *b = GIT_CONTAINER_OF(cfg, config_file_backend, parent);
-	git_config_entries *old = NULL;
+	git_config_list *old = NULL;
 	int error;
 
 	if (b->parent.readonly) {
@@ -190,40 +193,40 @@ static int config_file_set_entries(git_config_backend *cfg, git_config_entries *
 		goto out;
 	}
 
-	old = b->entries;
-	b->entries = entries;
+	old = b->config_list;
+	b->config_list = config_list;
 
 	git_mutex_unlock(&b->values_mutex);
 
 out:
-	git_config_entries_free(old);
+	git_config_list_free(old);
 	return error;
 }
 
 static int config_file_refresh_from_buffer(git_config_backend *cfg, const char *buf, size_t buflen)
 {
 	config_file_backend *b = GIT_CONTAINER_OF(cfg, config_file_backend, parent);
-	git_config_entries *entries = NULL;
+	git_config_list *config_list = NULL;
 	int error;
 
 	config_file_clear_includes(b);
 
-	if ((error = git_config_entries_new(&entries)) < 0 ||
-	    (error = config_file_read_buffer(entries, b->repo, &b->file,
+	if ((error = git_config_list_new(&config_list)) < 0 ||
+	    (error = config_file_read_buffer(config_list, b->repo, &b->file,
 					     b->level, 0, buf, buflen)) < 0 ||
-	    (error = config_file_set_entries(cfg, entries)) < 0)
+	    (error = config_file_set_entries(cfg, config_list)) < 0)
 		goto out;
 
-	entries = NULL;
+	config_list = NULL;
 out:
-	git_config_entries_free(entries);
+	git_config_list_free(config_list);
 	return error;
 }
 
 static int config_file_refresh(git_config_backend *cfg)
 {
 	config_file_backend *b = GIT_CONTAINER_OF(cfg, config_file_backend, parent);
-	git_config_entries *entries = NULL;
+	git_config_list *config_list = NULL;
 	int error, modified;
 
 	if (cfg->readonly)
@@ -237,14 +240,14 @@ static int config_file_refresh(git_config_backend *cfg)
 
 	config_file_clear_includes(b);
 
-	if ((error = git_config_entries_new(&entries)) < 0 ||
-	    (error = config_file_read(entries, b->repo, &b->file, b->level, 0)) < 0 ||
-	    (error = config_file_set_entries(cfg, entries)) < 0)
+	if ((error = git_config_list_new(&config_list)) < 0 ||
+	    (error = config_file_read(config_list, b->repo, &b->file, b->level, 0)) < 0 ||
+	    (error = config_file_set_entries(cfg, config_list)) < 0)
 		goto out;
 
-	entries = NULL;
+	config_list = NULL;
 out:
-	git_config_entries_free(entries);
+	git_config_list_free(config_list);
 
 	return (error == GIT_ENOTFOUND) ? 0 : error;
 }
@@ -257,7 +260,7 @@ static void config_file_free(git_config_backend *_backend)
 		return;
 
 	config_file_clear(&backend->file);
-	git_config_entries_free(backend->entries);
+	git_config_list_free(backend->config_list);
 	git_mutex_free(&backend->values_mutex);
 	git__free(backend);
 }
@@ -267,19 +270,19 @@ static int config_file_iterator(
 	struct git_config_backend *backend)
 {
 	config_file_backend *b = GIT_CONTAINER_OF(backend, config_file_backend, parent);
-	git_config_entries *dupped = NULL, *entries = NULL;
+	git_config_list *dupped = NULL, *config_list = NULL;
 	int error;
 
 	if ((error = config_file_refresh(backend)) < 0 ||
-	    (error = config_file_entries_take(&entries, b)) < 0 ||
-	    (error = git_config_entries_dup(&dupped, entries)) < 0 ||
-	    (error = git_config_entries_iterator_new(iter, dupped)) < 0)
+	    (error = config_file_take_list(&config_list, b)) < 0 ||
+	    (error = git_config_list_dup(&dupped, config_list)) < 0 ||
+	    (error = git_config_list_iterator_new(iter, dupped)) < 0)
 		goto out;
 
 out:
-	/* Let iterator delete duplicated entries when it's done */
-	git_config_entries_free(entries);
-	git_config_entries_free(dupped);
+	/* Let iterator delete duplicated config_list when it's done */
+	git_config_list_free(config_list);
+	git_config_list_free(dupped);
 	return error;
 }
 
@@ -291,24 +294,24 @@ static int config_file_snapshot(git_config_backend **out, git_config_backend *ba
 static int config_file_set(git_config_backend *cfg, const char *name, const char *value)
 {
 	config_file_backend *b = GIT_CONTAINER_OF(cfg, config_file_backend, parent);
-	git_config_entries *entries;
-	git_config_entry *existing;
+	git_config_list *config_list;
+	git_config_list_entry *existing;
 	char *key, *esc_value = NULL;
 	int error;
 
 	if ((error = git_config__normalize_name(name, &key)) < 0)
 		return error;
 
-	if ((error = config_file_entries_take(&entries, b)) < 0)
+	if ((error = config_file_take_list(&config_list, b)) < 0)
 		return error;
 
 	/* Check whether we'd be modifying an included or multivar key */
-	if ((error = git_config_entries_get_unique(&existing, entries, key)) < 0) {
+	if ((error = git_config_list_get_unique(&existing, config_list, key)) < 0) {
 		if (error != GIT_ENOTFOUND)
 			goto out;
 		error = 0;
-	} else if ((!existing->value && !value) ||
-		   (existing->value && value && !strcmp(existing->value, value))) {
+	} else if ((!existing->base.entry.value && !value) ||
+		   (existing->base.entry.value && value && !strcmp(existing->base.entry.value, value))) {
 		/* don't update if old and new values already match */
 		error = 0;
 		goto out;
@@ -324,43 +327,37 @@ static int config_file_set(git_config_backend *cfg, const char *name, const char
 		goto out;
 
 out:
-	git_config_entries_free(entries);
+	git_config_list_free(config_list);
 	git__free(esc_value);
 	git__free(key);
 	return error;
 }
 
-/* release the map containing the entry as an equivalent to freeing it */
-static void config_file_entry_free(git_config_entry *entry)
-{
-	git_config_entries *entries = (git_config_entries *) entry->payload;
-	git_config_entries_free(entries);
-}
-
 /*
  * Internal function that actually gets the value in string form
  */
-static int config_file_get(git_config_backend *cfg, const char *key, git_config_entry **out)
+static int config_file_get(
+	git_config_backend *cfg,
+	const char *key,
+	git_config_backend_entry **out)
 {
 	config_file_backend *h = GIT_CONTAINER_OF(cfg, config_file_backend, parent);
-	git_config_entries *entries = NULL;
-	git_config_entry *entry;
+	git_config_list *config_list = NULL;
+	git_config_list_entry *entry;
 	int error = 0;
 
 	if (!h->parent.readonly && ((error = config_file_refresh(cfg)) < 0))
 		return error;
 
-	if ((error = config_file_entries_take(&entries, h)) < 0)
+	if ((error = config_file_take_list(&config_list, h)) < 0)
 		return error;
 
-	if ((error = (git_config_entries_get(&entry, entries, key))) < 0) {
-		git_config_entries_free(entries);
+	if ((error = (git_config_list_get(&entry, config_list, key))) < 0) {
+		git_config_list_free(config_list);
 		return error;
 	}
 
-	entry->free = config_file_entry_free;
-	entry->payload = entries;
-	*out = entry;
+	*out = &entry->base;
 
 	return 0;
 }
@@ -395,29 +392,29 @@ out:
 static int config_file_delete(git_config_backend *cfg, const char *name)
 {
 	config_file_backend *b = GIT_CONTAINER_OF(cfg, config_file_backend, parent);
-	git_config_entries *entries = NULL;
-	git_config_entry *entry;
+	git_config_list *config_list = NULL;
+	git_config_list_entry *entry;
 	char *key = NULL;
 	int error;
 
 	if ((error = git_config__normalize_name(name, &key)) < 0)
 		goto out;
 
-	if ((error = config_file_entries_take(&entries, b)) < 0)
+	if ((error = config_file_take_list(&config_list, b)) < 0)
 		goto out;
 
 	/* 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_config_list_get_unique(&entry, config_list, key)) < 0) {
 		if (error == GIT_ENOTFOUND)
 			git_error_set(GIT_ERROR_CONFIG, "could not find key '%s' to delete", name);
 		goto out;
 	}
 
-	if ((error = config_file_write(b, name, entry->name, NULL, NULL)) < 0)
+	if ((error = config_file_write(b, name, entry->base.entry.name, NULL, NULL)) < 0)
 		goto out;
 
 out:
-	git_config_entries_free(entries);
+	git_config_list_free(config_list);
 	git__free(key);
 	return error;
 }
@@ -425,8 +422,8 @@ out:
 static int config_file_delete_multivar(git_config_backend *cfg, const char *name, const char *regexp)
 {
 	config_file_backend *b = GIT_CONTAINER_OF(cfg, config_file_backend, parent);
-	git_config_entries *entries = NULL;
-	git_config_entry *entry = NULL;
+	git_config_list *config_list = NULL;
+	git_config_list_entry *entry = NULL;
 	git_regexp preg = GIT_REGEX_INIT;
 	char *key = NULL;
 	int result;
@@ -434,10 +431,10 @@ static int config_file_delete_multivar(git_config_backend *cfg, const char *name
 	if ((result = git_config__normalize_name(name, &key)) < 0)
 		goto out;
 
-	if ((result = config_file_entries_take(&entries, b)) < 0)
+	if ((result = config_file_take_list(&config_list, b)) < 0)
 		goto out;
 
-	if ((result = git_config_entries_get(&entry, entries, key)) < 0) {
+	if ((result = git_config_list_get(&entry, config_list, key)) < 0) {
 		if (result == GIT_ENOTFOUND)
 			git_error_set(GIT_ERROR_CONFIG, "could not find key '%s' to delete", name);
 		goto out;
@@ -450,7 +447,7 @@ static int config_file_delete_multivar(git_config_backend *cfg, const char *name
 		goto out;
 
 out:
-	git_config_entries_free(entries);
+	git_config_list_free(config_list);
 	git__free(key);
 	git_regexp_dispose(&preg);
 	return result;
@@ -486,7 +483,7 @@ static int config_file_unlock(git_config_backend *_cfg, int success)
 	}
 
 	git_filebuf_cleanup(&cfg->locked_buf);
-	git_buf_dispose(&cfg->locked_content);
+	git_str_dispose(&cfg->locked_content);
 	cfg->locked = false;
 
 	return error;
@@ -523,19 +520,19 @@ int git_config_backend_from_file(git_config_backend **out, const char *path)
 	return 0;
 }
 
-static int included_path(git_buf *out, const char *dir, const char *path)
+static int included_path(git_str *out, const char *dir, const char *path)
 {
 	/* From the user's home */
 	if (path[0] == '~' && path[1] == '/')
-		return git_sysdir_expand_global_file(out, &path[1]);
+		return git_sysdir_expand_homedir_file(out, &path[1]);
 
-	return git_path_join_unrooted(out, path, dir, NULL);
+	return git_fs_path_join_unrooted(out, path, dir, NULL);
 }
 
 /* Escape the values to write them to the file */
 static char *escape_value(const char *ptr)
 {
-	git_buf buf;
+	git_str buf;
 	size_t len;
 	const char *esc;
 
@@ -545,39 +542,39 @@ static char *escape_value(const char *ptr)
 	if (!len)
 		return git__calloc(1, sizeof(char));
 
-	if (git_buf_init(&buf, len) < 0)
+	if (git_str_init(&buf, len) < 0)
 		return NULL;
 
 	while (*ptr != '\0') {
 		if ((esc = strchr(git_config_escaped, *ptr)) != NULL) {
-			git_buf_putc(&buf, '\\');
-			git_buf_putc(&buf, git_config_escapes[esc - git_config_escaped]);
+			git_str_putc(&buf, '\\');
+			git_str_putc(&buf, git_config_escapes[esc - git_config_escaped]);
 		} else {
-			git_buf_putc(&buf, *ptr);
+			git_str_putc(&buf, *ptr);
 		}
 		ptr++;
 	}
 
-	if (git_buf_oom(&buf))
+	if (git_str_oom(&buf))
 		return NULL;
 
-	return git_buf_detach(&buf);
+	return git_str_detach(&buf);
 }
 
 static int parse_include(config_file_parse_data *parse_data, const char *file)
 {
 	config_file *include;
-	git_buf path = GIT_BUF_INIT;
+	git_str path = GIT_STR_INIT;
 	char *dir;
 	int result;
 
 	if (!file)
 		return 0;
 
-	if ((result = git_path_dirname_r(&path, parse_data->file->path)) < 0)
+	if ((result = git_fs_path_dirname_r(&path, parse_data->file->path)) < 0)
 		return result;
 
-	dir = git_buf_detach(&path);
+	dir = git_str_detach(&path);
 	result = included_path(&path, dir, file);
 	git__free(dir);
 
@@ -588,9 +585,9 @@ static int parse_include(config_file_parse_data *parse_data, const char *file)
 	GIT_ERROR_CHECK_ALLOC(include);
 	memset(include, 0, sizeof(*include));
 	git_array_init(include->includes);
-	include->path = git_buf_detach(&path);
+	include->path = git_str_detach(&path);
 
-	result = config_file_read(parse_data->entries, parse_data->repo, include,
+	result = config_file_read(parse_data->config_list, parse_data->repo, include,
 				  parse_data->level, parse_data->depth+1);
 
 	if (result == GIT_ENOTFOUND) {
@@ -608,38 +605,38 @@ static int do_match_gitdir(
 	const char *condition,
 	bool case_insensitive)
 {
-	git_buf pattern = GIT_BUF_INIT, gitdir = GIT_BUF_INIT;
+	git_str pattern = GIT_STR_INIT, gitdir = GIT_STR_INIT;
 	int error;
 
-	if (condition[0] == '.' && git_path_is_dirsep(condition[1])) {
-		git_path_dirname_r(&pattern, cfg_file);
-		git_buf_joinpath(&pattern, pattern.ptr, condition + 2);
-	} else if (condition[0] == '~' && git_path_is_dirsep(condition[1]))
-		git_sysdir_expand_global_file(&pattern, condition + 1);
-	else if (!git_path_is_absolute(condition))
-		git_buf_joinpath(&pattern, "**", condition);
+	if (condition[0] == '.' && git_fs_path_is_dirsep(condition[1])) {
+		git_fs_path_dirname_r(&pattern, cfg_file);
+		git_str_joinpath(&pattern, pattern.ptr, condition + 2);
+	} else if (condition[0] == '~' && git_fs_path_is_dirsep(condition[1]))
+		git_sysdir_expand_homedir_file(&pattern, condition + 1);
+	else if (!git_fs_path_is_absolute(condition))
+		git_str_joinpath(&pattern, "**", condition);
 	else
-		git_buf_sets(&pattern, condition);
+		git_str_sets(&pattern, condition);
 
-	if (git_path_is_dirsep(condition[strlen(condition) - 1]))
-		git_buf_puts(&pattern, "**");
+	if (git_fs_path_is_dirsep(condition[strlen(condition) - 1]))
+		git_str_puts(&pattern, "**");
 
-	if (git_buf_oom(&pattern)) {
+	if (git_str_oom(&pattern)) {
 		error = -1;
 		goto out;
 	}
 
-	if ((error = git_repository_item_path(&gitdir, repo, GIT_REPOSITORY_ITEM_GITDIR)) < 0)
+	if ((error = git_repository__item_path(&gitdir, repo, GIT_REPOSITORY_ITEM_GITDIR)) < 0)
 		goto out;
 
-	if (git_path_is_dirsep(gitdir.ptr[gitdir.size - 1]))
-		git_buf_truncate(&gitdir, gitdir.size - 1);
+	if (git_fs_path_is_dirsep(gitdir.ptr[gitdir.size - 1]))
+		git_str_truncate(&gitdir, gitdir.size - 1);
 
 	*matches = wildmatch(pattern.ptr, gitdir.ptr,
 			     WM_PATHNAME | (case_insensitive ? WM_CASEFOLD : 0)) == WM_MATCH;
 out:
-	git_buf_dispose(&pattern);
-	git_buf_dispose(&gitdir);
+	git_str_dispose(&pattern);
+	git_str_dispose(&gitdir);
 	return error;
 }
 
@@ -667,7 +664,7 @@ static int conditional_match_onbranch(
 	const char *cfg_file,
 	const char *condition)
 {
-	git_buf reference = GIT_BUF_INIT, buf = GIT_BUF_INIT;
+	git_str reference = GIT_STR_INIT, buf = GIT_STR_INIT;
 	int error;
 
 	GIT_UNUSED(cfg_file);
@@ -680,33 +677,33 @@ static int conditional_match_onbranch(
 	 * an endless recursion.
 	 */
 
-	if ((error = git_buf_joinpath(&buf, git_repository_path(repo), GIT_HEAD_FILE)) < 0 ||
+	if ((error = git_str_joinpath(&buf, git_repository_path(repo), GIT_HEAD_FILE)) < 0 ||
 	    (error = git_futils_readbuffer(&reference, buf.ptr)) < 0)
 		goto out;
-	git_buf_rtrim(&reference);
+	git_str_rtrim(&reference);
 
 	if (git__strncmp(reference.ptr, GIT_SYMREF, strlen(GIT_SYMREF)))
 		goto out;
-	git_buf_consume(&reference, reference.ptr + strlen(GIT_SYMREF));
+	git_str_consume(&reference, reference.ptr + strlen(GIT_SYMREF));
 
 	if (git__strncmp(reference.ptr, GIT_REFS_HEADS_DIR, strlen(GIT_REFS_HEADS_DIR)))
 		goto out;
-	git_buf_consume(&reference, reference.ptr + strlen(GIT_REFS_HEADS_DIR));
+	git_str_consume(&reference, reference.ptr + strlen(GIT_REFS_HEADS_DIR));
 
 	/*
 	 * If the condition ends with a '/', then we should treat it as if
 	 * it had '**' appended.
 	 */
-	if ((error = git_buf_sets(&buf, condition)) < 0)
+	if ((error = git_str_sets(&buf, condition)) < 0)
 		goto out;
-	if (git_path_is_dirsep(condition[strlen(condition) - 1]) &&
-	    (error = git_buf_puts(&buf, "**")) < 0)
+	if (git_fs_path_is_dirsep(condition[strlen(condition) - 1]) &&
+	    (error = git_str_puts(&buf, "**")) < 0)
 		goto out;
 
 	*matches = wildmatch(buf.ptr, reference.ptr, WM_PATHNAME) == WM_MATCH;
 out:
-	git_buf_dispose(&reference);
-	git_buf_dispose(&buf);
+	git_str_dispose(&reference);
+	git_str_dispose(&buf);
 
 	return error;
 
@@ -724,14 +721,25 @@ static const struct {
 static int parse_conditional_include(config_file_parse_data *parse_data, const char *section, const char *file)
 {
 	char *condition;
-	size_t i;
+	size_t section_len, i;
 	int error = 0, matches;
 
 	if (!parse_data->repo || !file)
 		return 0;
 
-	condition = git__substrdup(section + strlen("includeIf."),
-				   strlen(section) - strlen("includeIf.") - strlen(".path"));
+	section_len = strlen(section);
+
+	/*
+	 * We checked that the string starts with `includeIf.` and ends
+	 * in `.path` to get here.  Make sure it consists of more.
+	 */
+	if (section_len < CONST_STRLEN("includeIf.") + CONST_STRLEN(".path"))
+		return 0;
+
+	condition = git__substrdup(section + CONST_STRLEN("includeIf."),
+		section_len - CONST_STRLEN("includeIf.") - CONST_STRLEN(".path"));
+
+	GIT_ERROR_CHECK_ALLOC(condition);
 
 	for (i = 0; i < ARRAY_SIZE(conditions); i++) {
 		if (git__prefixcmp(condition, conditions[i].prefix))
@@ -763,8 +771,8 @@ static int read_on_variable(
 	void *data)
 {
 	config_file_parse_data *parse_data = (config_file_parse_data *)data;
-	git_buf buf = GIT_BUF_INIT;
-	git_config_entry *entry;
+	git_str buf = GIT_STR_INIT;
+	git_config_list_entry *entry;
 	const char *c;
 	int result = 0;
 
@@ -777,40 +785,55 @@ static int read_on_variable(
 		 * here. Git appears to warn in most cases if it sees
 		 * un-namespaced config options.
 		 */
-		git_buf_puts(&buf, current_section);
-		git_buf_putc(&buf, '.');
+		git_str_puts(&buf, current_section);
+		git_str_putc(&buf, '.');
 	}
 
 	for (c = var_name; *c; c++)
-		git_buf_putc(&buf, git__tolower(*c));
+		git_str_putc(&buf, git__tolower(*c));
 
-	if (git_buf_oom(&buf))
+	if (git_str_oom(&buf))
 		return -1;
 
-	entry = git__calloc(1, sizeof(git_config_entry));
+	entry = git__calloc(1, sizeof(git_config_list_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 = git_config_entries_append(parse_data->entries, entry)) < 0)
+	entry->base.entry.name = git_str_detach(&buf);
+	GIT_ERROR_CHECK_ALLOC(entry->base.entry.name);
+
+	if (var_value) {
+		entry->base.entry.value = git__strdup(var_value);
+		GIT_ERROR_CHECK_ALLOC(entry->base.entry.value);
+	}
+
+	entry->base.entry.backend_type = git_config_list_add_string(parse_data->config_list, CONFIG_FILE_TYPE);
+	GIT_ERROR_CHECK_ALLOC(entry->base.entry.backend_type);
+
+	entry->base.entry.origin_path = git_config_list_add_string(parse_data->config_list, parse_data->file->path);
+	GIT_ERROR_CHECK_ALLOC(entry->base.entry.origin_path);
+
+	entry->base.entry.level = parse_data->level;
+	entry->base.entry.include_depth = parse_data->depth;
+	entry->base.free = git_config_list_entry_free;
+	entry->config_list = parse_data->config_list;
+
+	if ((result = git_config_list_append(parse_data->config_list, entry)) < 0)
 		return result;
 
 	result = 0;
 
 	/* Add or append the new config option */
-	if (!git__strcmp(entry->name, "include.path"))
-		result = parse_include(parse_data, entry->value);
-	else if (!git__prefixcmp(entry->name, "includeif.") &&
-	         !git__suffixcmp(entry->name, ".path"))
-		result = parse_conditional_include(parse_data, entry->name, entry->value);
+	if (!git__strcmp(entry->base.entry.name, "include.path"))
+		result = parse_include(parse_data, entry->base.entry.value);
+	else if (!git__prefixcmp(entry->base.entry.name, "includeif.") &&
+	         !git__suffixcmp(entry->base.entry.name, ".path"))
+		result = parse_conditional_include(parse_data, entry->base.entry.name, entry->base.entry.value);
 
 	return result;
 }
 
 static int config_file_read_buffer(
-	git_config_entries *entries,
+	git_config_list *config_list,
 	const git_repository *repo,
 	config_file *file,
 	git_config_level_t level,
@@ -839,7 +862,7 @@ static int config_file_read_buffer(
 
 	parse_data.repo = repo;
 	parse_data.file = file;
-	parse_data.entries = entries;
+	parse_data.config_list = config_list;
 	parse_data.level = level;
 	parse_data.depth = depth;
 
@@ -850,18 +873,18 @@ out:
 }
 
 static int config_file_read(
-	git_config_entries *entries,
+	git_config_list *config_list,
 	const git_repository *repo,
 	config_file *file,
 	git_config_level_t level,
 	int depth)
 {
-	git_buf contents = GIT_BUF_INIT;
+	git_str contents = GIT_STR_INIT;
 	struct stat st;
 	int error;
 
 	if (p_stat(file->path, &st) < 0) {
-		error = git_path_set_error(errno, file->path, "stat");
+		error = git_fs_path_set_error(errno, file->path, "stat");
 		goto out;
 	}
 
@@ -869,44 +892,44 @@ static int config_file_read(
 		goto out;
 
 	git_futils_filestamp_set_from_stat(&file->stamp, &st);
-	if ((error = git_hash_buf(&file->checksum, contents.ptr, contents.size)) < 0)
+	if ((error = git_hash_buf(file->checksum, contents.ptr, contents.size, GIT_HASH_ALGORITHM_SHA256)) < 0)
 		goto out;
 
-	if ((error = config_file_read_buffer(entries, repo, file, level, depth,
+	if ((error = config_file_read_buffer(config_list, repo, file, level, depth,
 					     contents.ptr, contents.size)) < 0)
 		goto out;
 
 out:
-	git_buf_dispose(&contents);
+	git_str_dispose(&contents);
 	return error;
 }
 
-static int write_section(git_buf *fbuf, const char *key)
+static int write_section(git_str *fbuf, const char *key)
 {
 	int result;
 	const char *dot;
-	git_buf buf = GIT_BUF_INIT;
+	git_str buf = GIT_STR_INIT;
 
 	/* All of this just for [section "subsection"] */
 	dot = strchr(key, '.');
-	git_buf_putc(&buf, '[');
+	git_str_putc(&buf, '[');
 	if (dot == NULL) {
-		git_buf_puts(&buf, key);
+		git_str_puts(&buf, key);
 	} else {
 		char *escaped;
-		git_buf_put(&buf, key, dot - key);
+		git_str_put(&buf, key, dot - key);
 		escaped = escape_value(dot + 1);
 		GIT_ERROR_CHECK_ALLOC(escaped);
-		git_buf_printf(&buf, " \"%s\"", escaped);
+		git_str_printf(&buf, " \"%s\"", escaped);
 		git__free(escaped);
 	}
-	git_buf_puts(&buf, "]\n");
+	git_str_puts(&buf, "]\n");
 
-	if (git_buf_oom(&buf))
+	if (git_str_oom(&buf))
 		return -1;
 
-	result = git_buf_put(fbuf, git_buf_cstr(&buf), buf.size);
-	git_buf_dispose(&buf);
+	result = git_str_put(fbuf, git_str_cstr(&buf), buf.size);
+	git_str_dispose(&buf);
 
 	return result;
 }
@@ -930,8 +953,8 @@ static const char *quotes_for_value(const char *value)
 }
 
 struct write_data {
-	git_buf *buf;
-	git_buf buffered_comment;
+	git_str *buf;
+	git_str buffered_comment;
 	unsigned int in_section : 1,
 		preg_replaced : 1;
 	const char *orig_section;
@@ -942,12 +965,12 @@ struct write_data {
 	const char *value;
 };
 
-static int write_line_to(git_buf *buf, const char *line, size_t line_len)
+static int write_line_to(git_str *buf, const char *line, size_t line_len)
 {
-	int result = git_buf_put(buf, line, line_len);
+	int result = git_str_put(buf, line, line_len);
 
 	if (!result && line_len && line[line_len-1] != '\n')
-		result = git_buf_printf(buf, "\n");
+		result = git_str_printf(buf, "\n");
 
 	return result;
 }
@@ -963,7 +986,7 @@ static int write_value(struct write_data *write_data)
 	int result;
 
 	q = quotes_for_value(write_data->value);
-	result = git_buf_printf(write_data->buf,
+	result = git_str_printf(write_data->buf,
 		"\t%s = %s%s%s\n", write_data->orig_name, q, write_data->value, q);
 
 	/* If we are updating a single name/value, we're done.  Setting `value`
@@ -1002,8 +1025,8 @@ static int write_on_section(
 	 * If there were comments just before this section, dump them as well.
 	 */
 	if (!result) {
-		result = git_buf_put(write_data->buf, write_data->buffered_comment.ptr, write_data->buffered_comment.size);
-		git_buf_clear(&write_data->buffered_comment);
+		result = git_str_put(write_data->buf, write_data->buffered_comment.ptr, write_data->buffered_comment.size);
+		git_str_clear(&write_data->buffered_comment);
 	}
 
 	if (!result)
@@ -1031,10 +1054,10 @@ static int write_on_variable(
 	/*
 	 * If there were comments just before this variable, let's dump them as well.
 	 */
-	if ((error = git_buf_put(write_data->buf, write_data->buffered_comment.ptr, write_data->buffered_comment.size)) < 0)
+	if ((error = git_str_put(write_data->buf, write_data->buffered_comment.ptr, write_data->buffered_comment.size)) < 0)
 		return error;
 
-	git_buf_clear(&write_data->buffered_comment);
+	git_str_clear(&write_data->buffered_comment);
 
 	/* See if we are to update this name/value pair; first examine name */
 	if (write_data->in_section &&
@@ -1081,7 +1104,7 @@ static int write_on_eof(
 	/*
 	 * If we've buffered comments when reaching EOF, make sure to dump them.
 	 */
-	if ((result = git_buf_put(write_data->buf, write_data->buffered_comment.ptr, write_data->buffered_comment.size)) < 0)
+	if ((result = git_str_put(write_data->buf, write_data->buffered_comment.ptr, write_data->buffered_comment.size)) < 0)
 		return result;
 
 	/* If we are at the EOF and have not written our value (again, for a
@@ -1104,11 +1127,16 @@ static int write_on_eof(
 /*
  * This is pretty much the parsing, except we write out anything we don't have
  */
-static int config_file_write(config_file_backend *cfg, const char *orig_key, const char *key, const git_regexp *preg, const char *value)
+static int config_file_write(
+	config_file_backend *cfg,
+	const char *orig_key,
+	const char *key,
+	const git_regexp *preg,
+	const char *value)
 
 {
 	char *orig_section = NULL, *section = NULL, *orig_name, *name, *ldot;
-	git_buf buf = GIT_BUF_INIT, contents = GIT_BUF_INIT;
+	git_str buf = GIT_STR_INIT, contents = GIT_STR_INIT;
 	git_config_parser parser = GIT_CONFIG_PARSER_INIT;
 	git_filebuf file = GIT_FILEBUF_INIT;
 	struct write_data write_data;
@@ -1117,10 +1145,11 @@ static int config_file_write(config_file_backend *cfg, const char *orig_key, con
 	memset(&write_data, 0, sizeof(write_data));
 
 	if (cfg->locked) {
-		error = git_buf_puts(&contents, git_buf_cstr(&cfg->locked_content) == NULL ? "" : git_buf_cstr(&cfg->locked_content));
+		error = git_str_puts(&contents, git_str_cstr(&cfg->locked_content) == NULL ? "" : git_str_cstr(&cfg->locked_content));
 	} else {
-		if ((error = git_filebuf_open(&file, cfg->file.path, GIT_FILEBUF_HASH_CONTENTS,
-					      GIT_CONFIG_FILE_MODE)) < 0)
+		if ((error = git_filebuf_open(&file, cfg->file.path,
+				GIT_FILEBUF_HASH_SHA256,
+				GIT_CONFIG_FILE_MODE)) < 0)
 			goto done;
 
 		/* We need to read in our own config file */
@@ -1157,10 +1186,10 @@ static int config_file_write(config_file_backend *cfg, const char *orig_key, con
 	if (cfg->locked) {
 		size_t len = buf.asize;
 		/* Update our copy with the modified contents */
-		git_buf_dispose(&cfg->locked_content);
-		git_buf_attach(&cfg->locked_content, git_buf_detach(&buf), len);
+		git_str_dispose(&cfg->locked_content);
+		git_str_attach(&cfg->locked_content, git_str_detach(&buf), len);
 	} else {
-		git_filebuf_write(&file, git_buf_cstr(&buf), git_buf_len(&buf));
+		git_filebuf_write(&file, git_str_cstr(&buf), git_str_len(&buf));
 
 		if ((error = git_filebuf_commit(&file)) < 0)
 			goto done;
@@ -1172,9 +1201,9 @@ static int config_file_write(config_file_backend *cfg, const char *orig_key, con
 done:
 	git__free(section);
 	git__free(orig_section);
-	git_buf_dispose(&write_data.buffered_comment);
-	git_buf_dispose(&buf);
-	git_buf_dispose(&contents);
+	git_str_dispose(&write_data.buffered_comment);
+	git_str_dispose(&buf);
+	git_str_dispose(&contents);
 	git_filebuf_cleanup(&file);
 	git_config_parser_dispose(&parser);