rugged 0.19.0 → 0.28.0

data/vendor/libgit2/src/config_file.c

@@ -5,234 +5,211 @@
  * a Linking Exception. For full terms see the included COPYING file.
  */
 
-#include "common.h"
 #include "config.h"
-#include "fileops.h"
+
 #include "filebuf.h"
+#include "sysdir.h"
 #include "buffer.h"
 #include "buf_text.h"
 #include "git2/config.h"
 #include "git2/sys/config.h"
 #include "git2/types.h"
 #include "strmap.h"
+#include "array.h"
+#include "config_parse.h"
+#include "config_entries.h"
 
 #include <ctype.h>
 #include <sys/types.h>
 #include <regex.h>
 
-GIT__USE_STRMAP;
-
-typedef struct cvar_t {
-	struct cvar_t *next;
-	git_config_entry *entry;
-} cvar_t;
-
-#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)
+/* Max depth for [include] directives */
+#define MAX_INCLUDE_DEPTH 10
 
-#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)
+typedef struct {
+	git_config_backend parent;
+	/* mutex to coordinate accessing the values */
+	git_mutex values_mutex;
+	git_config_entries *entries;
+	const git_repository *repo;
+	git_config_level_t level;
+} diskfile_header;
 
-#define CVAR_LIST_REMOVE_HEAD(list) do {\
-	CVAR_LIST_HEAD(list) = CVAR_LIST_NEXT(CVAR_LIST_HEAD(list));\
-} while(0)
+typedef struct {
+	diskfile_header header;
 
-#define CVAR_LIST_REMOVE_AFTER(var) do {\
-	CVAR_LIST_NEXT(var) = CVAR_LIST_NEXT(CVAR_LIST_NEXT(var));\
-} while(0)
+	git_array_t(git_config_parser) readers;
 
-#define CVAR_LIST_FOREACH(list, iter)\
-	for ((iter) = CVAR_LIST_HEAD(list);\
-		 (iter) != NULL;\
-		 (iter) = CVAR_LIST_NEXT(iter))
+	bool locked;
+	git_filebuf locked_buf;
+	git_buf locked_content;
 
-/*
- * 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))
+	struct config_file file;
+} diskfile_backend;
 
 typedef struct {
-	git_config_backend parent;
-
-	git_strmap *values;
+	diskfile_header header;
 
-	struct {
-		git_buf buffer;
-		char *read_ptr;
-		int line_number;
-		int eof;
-	} reader;
-
-	char  *file_path;
-	time_t file_mtime;
-	size_t file_size;
+	diskfile_backend *snapshot_from;
+} diskfile_readonly_backend;
 
+typedef struct {
+	const git_repository *repo;
+	const char *file_path;
+	git_config_entries *entries;
 	git_config_level_t level;
-} diskfile_backend;
+	unsigned int depth;
+} diskfile_parse_state;
 
-static int config_parse(diskfile_backend *cfg_file, git_config_level_t level);
-static int parse_variable(diskfile_backend *cfg, char **var_name, char **var_value);
-static int config_write(diskfile_backend *cfg, const char *key, const regex_t *preg, const char *value);
+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);
 
-static void set_parse_error(diskfile_backend *backend, int col, const char *error_str)
+static int config_snapshot(git_config_backend **out, git_config_backend *in);
+
+static int config_error_readonly(void)
 {
-	giterr_set(GITERR_CONFIG, "Failed to parse config file: %s (in %s:%d, column %d)",
-		error_str, backend->file_path, backend->reader.line_number, col);
+	git_error_set(GIT_ERROR_CONFIG, "this backend is read-only");
+	return -1;
 }
 
-static void cvar_free(cvar_t *var)
+/**
+ * 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 git_config_entries *diskfile_entries_take(diskfile_header *h)
 {
-	if (var == NULL)
-		return;
+	git_config_entries *entries;
+
+	if (git_mutex_lock(&h->values_mutex) < 0) {
+	    git_error_set(GIT_ERROR_OS, "failed to lock config backend");
+	    return NULL;
+	}
 
-	git__free((char*)var->entry->name);
-	git__free((char *)var->entry->value);
-	git__free(var->entry);
-	git__free(var);
+	entries = h->entries;
+	git_config_entries_incref(entries);
+
+	git_mutex_unlock(&h->values_mutex);
+
+	return entries;
 }
 
-int git_config_file_normalize_section(char *start, char *end)
+static void config_file_clear(struct config_file *file)
 {
-	char *scan;
+	struct config_file *include;
+	uint32_t i;
 
-	if (start == end)
-		return GIT_EINVALIDSPEC;
+	if (file == NULL)
+		return;
 
-	/* Validate and downcase range */
-	for (scan = start; *scan; ++scan) {
-		if (end && scan >= end)
-			break;
-		if (isalnum(*scan))
-			*scan = tolower(*scan);
-		else if (*scan != '-' || scan == start)
-			return GIT_EINVALIDSPEC;
+	git_array_foreach(file->includes, i, include) {
+		config_file_clear(include);
 	}
+	git_array_clear(file->includes);
 
-	if (scan == start)
-		return GIT_EINVALIDSPEC;
-
-	return 0;
+	git__free(file->path);
 }
 
-/* Take something the user gave us and make it nice for our hash function */
-static int normalize_name(const char *in, char **out)
+static int config_open(git_config_backend *cfg, git_config_level_t level, const git_repository *repo)
 {
-	char *name, *fdot, *ldot;
+	int res;
+	diskfile_backend *b = (diskfile_backend *)cfg;
 
-	assert(in && out);
+	b->header.level = level;
+	b->header.repo = repo;
 
-	name = git__strdup(in);
-	GITERR_CHECK_ALLOC(name);
+	if ((res = git_config_entries_new(&b->header.entries)) < 0)
+		return res;
 
-	fdot = strchr(name, '.');
-	ldot = strrchr(name, '.');
+	if (!git_path_exists(b->file.path))
+		return 0;
 
-	if (fdot == NULL || fdot == name || ldot == NULL || !ldot[1])
-		goto invalid;
+	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;
+	}
 
-	/* Validate and downcase up to first dot and after last dot */
-	if (git_config_file_normalize_section(name, fdot) < 0 ||
-		git_config_file_normalize_section(ldot + 1, NULL) < 0)
-		goto invalid;
+	return res;
+}
 
-	/* If there is a middle range, make sure it doesn't have newlines */
-	while (fdot < ldot)
-		if (*fdot++ == '\n')
-			goto invalid;
+static int config_is_modified(int *modified, struct config_file *file)
+{
+	git_config_file *include;
+	git_buf buf = GIT_BUF_INIT;
+	git_oid hash;
+	uint32_t i;
+	int error = 0;
 
-	*out = name;
-	return 0;
+	*modified = 0;
 
-invalid:
-	git__free(name);
-	giterr_set(GITERR_CONFIG, "Invalid config item name '%s'", in);
-	return GIT_EINVALIDSPEC;
-}
+	if ((error = git_futils_readbuffer(&buf, file->path)) < 0)
+		goto out;
 
-static void free_vars(git_strmap *values)
-{
-	cvar_t *var = NULL;
+	if ((error = git_hash_buf(&hash, buf.ptr, buf.size)) < 0)
+		goto out;
 
-	if (values == NULL)
-		return;
+	if (!git_oid_equal(&hash, &file->checksum)) {
+		*modified = 1;
+		goto out;
+	}
 
-	git_strmap_foreach_value(values, var,
-		while (var != NULL) {
-			cvar_t *next = CVAR_LIST_NEXT(var);
-			cvar_free(var);
-			var = next;
-		});
+	git_array_foreach(file->includes, i, include) {
+		if ((error = config_is_modified(modified, include)) < 0 || *modified)
+			goto out;
+	}
 
-	git_strmap_free(values);
+out:
+	git_buf_dispose(&buf);
+
+	return error;
 }
 
-static int config_open(git_config_backend *cfg, git_config_level_t level)
+static int config_refresh(git_config_backend *cfg)
 {
-	int res;
 	diskfile_backend *b = (diskfile_backend *)cfg;
+	git_config_entries *entries = NULL, *tmp;
+	git_config_file *include;
+	int error, modified;
+	uint32_t i;
 
-	b->level = level;
+	if (b->header.parent.readonly)
+		return config_error_readonly();
 
-	b->values = git_strmap_alloc();
-	GITERR_CHECK_ALLOC(b->values);
+	error = config_is_modified(&modified, &b->file);
+	if (error < 0 && error != GIT_ENOTFOUND)
+		goto out;
 
-	git_buf_init(&b->reader.buffer, 0);
-	res = git_futils_readbuffer_updated(
-		&b->reader.buffer, b->file_path, &b->file_mtime, &b->file_size, NULL);
-
-	/* It's fine if the file doesn't exist */
-	if (res == GIT_ENOTFOUND)
+	if (!modified)
 		return 0;
 
-	if (res < 0 || (res = config_parse(b, level)) < 0) {
-		free_vars(b->values);
-		b->values = NULL;
+	if ((error = git_config_entries_new(&entries)) < 0)
+		goto out;
+
+	/* Reparse the current configuration */
+	git_array_foreach(b->file.includes, i, include) {
+		config_file_clear(include);
 	}
+	git_array_clear(b->file.includes);
 
-	git_buf_free(&b->reader.buffer);
-	return res;
-}
+	if ((error = config_read(entries, b->header.repo, &b->file, b->header.level, 0)) < 0)
+		goto out;
 
-static int config_refresh(git_config_backend *cfg)
-{
-	int res, updated = 0;
-	diskfile_backend *b = (diskfile_backend *)cfg;
-	git_strmap *old_values;
+	if ((error = git_mutex_lock(&b->header.values_mutex)) < 0) {
+		git_error_set(GIT_ERROR_OS, "failed to lock config backend");
+		goto out;
+	}
 
-	res = git_futils_readbuffer_updated(
-		&b->reader.buffer, b->file_path, &b->file_mtime, &b->file_size, &updated);
-	if (res < 0 || !updated)
-		return (res == GIT_ENOTFOUND) ? 0 : res;
+	tmp = b->header.entries;
+	b->header.entries = entries;
+	entries = tmp;
 
-	/* need to reload - store old values and prep for reload */
-	old_values = b->values;
-	b->values = git_strmap_alloc();
-	GITERR_CHECK_ALLOC(b->values);
+	git_mutex_unlock(&b->header.values_mutex);
 
-	if ((res = config_parse(b, b->level)) < 0) {
-		free_vars(b->values);
-		b->values = old_values;
-	} else {
-		free_vars(old_values);
-	}
+out:
+	git_config_entries_free(entries);
 
-	git_buf_free(&b->reader.buffer);
-	return res;
+	return (error == GIT_ENOTFOUND) ? 0 : error;
 }
 
 static void backend_free(git_config_backend *_backend)
@@ -242,817 +219,684 @@ static void backend_free(git_config_backend *_backend)
 	if (backend == NULL)
 		return;
 
-	git__free(backend->file_path);
-	free_vars(backend->values);
+	config_file_clear(&backend->file);
+	git_config_entries_free(backend->header.entries);
+	git_mutex_free(&backend->header.values_mutex);
 	git__free(backend);
 }
 
-static int file_foreach(
-	git_config_backend *backend,
-	const char *regexp,
-	int (*fn)(const git_config_entry *, void *),
-	void *data)
+static int config_iterator_new(
+	git_config_iterator **iter,
+	struct git_config_backend* backend)
 {
-	diskfile_backend *b = (diskfile_backend *)backend;
-	cvar_t *var, *next_var;
-	const char *key;
-	regex_t regex;
-	int result = 0;
-
-	if (!b->values)
-		return 0;
-
-	if (regexp != NULL) {
-		if ((result = regcomp(&regex, regexp, REG_EXTENDED)) < 0) {
-			giterr_set_regex(&regex, result);
-			regfree(&regex);
-			return -1;
-		}
-	}
-
-	git_strmap_foreach(b->values, key, var,
-		for (; var != NULL; var = next_var) {
-			next_var = CVAR_LIST_NEXT(var);
-
-			/* skip non-matching keys if regexp was provided */
-			if (regexp && regexec(&regex, key, 0, NULL, 0) != 0)
-				continue;
+	diskfile_header *bh = (diskfile_header *) backend;
+	git_config_entries *entries;
+	int error;
 
-			/* abort iterator on non-zero return value */
-			if (fn(var->entry, data)) {
-				giterr_clear();
-				result = GIT_EUSER;
-				goto cleanup;
-			}
-		}
-	);
+	if ((error = git_config_entries_dup(&entries, bh->entries)) < 0)
+		return error;
 
-cleanup:
-	if (regexp != NULL)
-		regfree(&regex);
+	if ((error = git_config_entries_iterator_new(iter, entries)) < 0)
+		goto out;
 
-	return result;
+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)
 {
-	cvar_t *var = NULL, *old_var = NULL;
 	diskfile_backend *b = (diskfile_backend *)cfg;
+	git_config_entries *entries;
+	git_config_entry *existing;
 	char *key, *esc_value = NULL;
-	khiter_t pos;
-	int rval, ret;
-
-	if ((rval = normalize_name(name, &key)) < 0)
-		return rval;
-
-	/*
-	 * Try to find it in the existing values and update it if it
-	 * only has one value.
-	 */
-	pos = git_strmap_lookup_index(b->values, key);
-	if (git_strmap_valid_index(b->values, pos)) {
-		cvar_t *existing = git_strmap_value_at(b->values, pos);
-		char *tmp = NULL;
+	int error;
 
-		git__free(key);
+	if ((error = git_config__normalize_name(name, &key)) < 0)
+		return error;
 
-		if (existing->next != NULL) {
-			giterr_set(GITERR_CONFIG, "Multivar incompatible with simple set");
-			return -1;
-		}
+	if ((entries = diskfile_entries_take(&b->header)) == NULL)
+		return -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;
+		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)))
-			return 0;
-
-		if (value) {
-			tmp = git__strdup(value);
-			GITERR_CHECK_ALLOC(tmp);
-			esc_value = escape_value(value);
-			GITERR_CHECK_ALLOC(esc_value);
-		}
-
-		git__free((void *)existing->entry->value);
-		existing->entry->value = tmp;
-
-		ret = config_write(b, existing->entry->name, NULL, esc_value);
-
-		git__free(esc_value);
-		return ret;
+		error = 0;
+		goto out;
 	}
 
-	var = git__malloc(sizeof(cvar_t));
-	GITERR_CHECK_ALLOC(var);
-	memset(var, 0x0, sizeof(cvar_t));
-	var->entry = git__malloc(sizeof(git_config_entry));
-	GITERR_CHECK_ALLOC(var->entry);
-	memset(var->entry, 0x0, sizeof(git_config_entry));
-
-	var->entry->name = key;
-	var->entry->value = NULL;
-
+	/* No early returns due to sanity checks, let's write it out and refresh */
 	if (value) {
-		var->entry->value = git__strdup(value);
-		GITERR_CHECK_ALLOC(var->entry->value);
 		esc_value = escape_value(value);
-		GITERR_CHECK_ALLOC(esc_value);
+		GIT_ERROR_CHECK_ALLOC(esc_value);
 	}
 
-	if (config_write(b, key, NULL, esc_value) < 0) {
-		git__free(esc_value);
-		cvar_free(var);
-		return -1;
-	}
+	if ((error = config_write(b, name, key, NULL, esc_value)) < 0)
+		goto out;
 
+	error = config_refresh(cfg);
+
+out:
+	git_config_entries_free(entries);
 	git__free(esc_value);
-	git_strmap_insert2(b->values, key, var, old_var, rval);
-	if (rval < 0)
-		return -1;
-	if (old_var != NULL)
-		cvar_free(old_var);
+	git__free(key);
+	return error;
+}
 
-	return 0;
+/* release the map containing the entry as an equivalent to freeing it */
+static void free_diskfile_entry(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_get(const git_config_backend *cfg, const char *name, const git_config_entry **out)
+static int config_get(git_config_backend *cfg, const char *key, git_config_entry **out)
 {
-	diskfile_backend *b = (diskfile_backend *)cfg;
-	char *key;
-	khiter_t pos;
-	int error;
+	diskfile_header *h = (diskfile_header *)cfg;
+	git_config_entries *entries = NULL;
+	git_config_entry *entry;
+	int error = 0;
 
-	if ((error = normalize_name(name, &key)) < 0)
+	if (!h->parent.readonly && ((error = config_refresh(cfg)) < 0))
 		return error;
 
-	pos = git_strmap_lookup_index(b->values, key);
-	git__free(key);
-
-	/* no error message; the config system will write one */
-	if (!git_strmap_valid_index(b->values, pos))
-		return GIT_ENOTFOUND;
-
-	*out = ((cvar_t *)git_strmap_value_at(b->values, pos))->entry;
-
-	return 0;
-}
-
-static int config_get_multivar(
-	git_config_backend *cfg,
-	const char *name,
-	const char *regex_str,
-	int (*fn)(const git_config_entry *, void *),
-	void *data)
-{
-	cvar_t *var;
-	diskfile_backend *b = (diskfile_backend *)cfg;
-	char *key;
-	khiter_t pos;
-	int error;
+	if ((entries = diskfile_entries_take(h)) == NULL)
+		return -1;
 
-	if ((error = normalize_name(name, &key)) < 0)
+	if ((error = (git_config_entries_get(&entry, entries, key))) < 0) {
+		git_config_entries_free(entries);
 		return error;
-
-	pos = git_strmap_lookup_index(b->values, key);
-	git__free(key);
-
-	if (!git_strmap_valid_index(b->values, pos))
-		return GIT_ENOTFOUND;
-
-	var = git_strmap_value_at(b->values, pos);
-
-	if (regex_str != NULL) {
-		regex_t regex;
-		int result;
-
-		/* regex matching; build the regex */
-		result = regcomp(&regex, regex_str, REG_EXTENDED);
-		if (result < 0) {
-			giterr_set_regex(&regex, result);
-			regfree(&regex);
-			return -1;
-		}
-
-		/* and throw the callback only on the variables that
-		 * match the regex */
-		do {
-			if (regexec(&regex, var->entry->value, 0, NULL, 0) == 0) {
-				/* early termination by the user is not an error;
-				 * just break and return successfully */
-				if (fn(var->entry, data) < 0)
-					break;
-			}
-
-			var = var->next;
-		} while (var != NULL);
-		regfree(&regex);
-	} else {
-		/* no regex; go through all the variables */
-		do {
-			/* early termination by the user is not an error;
-			 * just break and return successfully */
-			if (fn(var->entry, data) < 0)
-				break;
-
-			var = var->next;
-		} while (var != NULL);
 	}
 
+	entry->free = free_diskfile_entry;
+	entry->payload = entries;
+	*out = entry;
+
 	return 0;
 }
 
 static int config_set_multivar(
 	git_config_backend *cfg, const char *name, const char *regexp, const char *value)
 {
-	int replaced = 0;
-	cvar_t *var, *newvar;
 	diskfile_backend *b = (diskfile_backend *)cfg;
 	char *key;
 	regex_t preg;
 	int result;
-	khiter_t pos;
 
 	assert(regexp);
 
-	if ((result = normalize_name(name, &key)) < 0)
-		return result;
-
-	pos = git_strmap_lookup_index(b->values, key);
-	if (!git_strmap_valid_index(b->values, pos)) {
-		/* If we don't have it, behave like a normal set */
-		result = config_set(cfg, name, value);
-		git__free(key);
+	if ((result = git_config__normalize_name(name, &key)) < 0)
 		return result;
-	}
 
-	var = git_strmap_value_at(b->values, pos);
-
-	result = regcomp(&preg, regexp, REG_EXTENDED);
-	if (result < 0) {
-		git__free(key);
-		giterr_set_regex(&preg, result);
-		regfree(&preg);
-		return -1;
+	result = p_regcomp(&preg, regexp, REG_EXTENDED);
+	if (result != 0) {
+		git_error_set_regex(&preg, result);
+		result = -1;
+		goto out;
 	}
 
-	for (;;) {
-		if (regexec(&preg, var->entry->value, 0, NULL, 0) == 0) {
-			char *tmp = git__strdup(value);
-			GITERR_CHECK_ALLOC(tmp);
-
-			git__free((void *)var->entry->value);
-			var->entry->value = tmp;
-			replaced = 1;
-		}
+	/* If we do have it, set call config_write() and reload */
+	if ((result = config_write(b, name, key, &preg, value)) < 0)
+		goto out;
 
-		if (var->next == NULL)
-			break;
+	result = config_refresh(cfg);
 
-		var = var->next;
-	}
+out:
+	git__free(key);
+	regfree(&preg);
 
-	/* If we've reached the end of the variables and we haven't found it yet, we need to append it */
-	if (!replaced) {
-		newvar = git__malloc(sizeof(cvar_t));
-		GITERR_CHECK_ALLOC(newvar);
-		memset(newvar, 0x0, sizeof(cvar_t));
-		newvar->entry = git__malloc(sizeof(git_config_entry));
-		GITERR_CHECK_ALLOC(newvar->entry);
-		memset(newvar->entry, 0x0, sizeof(git_config_entry));
+	return result;
+}
 
-		newvar->entry->name = git__strdup(var->entry->name);
-		GITERR_CHECK_ALLOC(newvar->entry->name);
+static int config_delete(git_config_backend *cfg, const char *name)
+{
+	diskfile_backend *b = (diskfile_backend *)cfg;
+	git_config_entries *entries = NULL;
+	git_config_entry *entry;
+	char *key = NULL;
+	int error;
 
-		newvar->entry->value = git__strdup(value);
-		GITERR_CHECK_ALLOC(newvar->entry->value);
+	if ((error = git_config__normalize_name(name, &key)) < 0)
+		goto out;
 
-		newvar->entry->level = var->entry->level;
+	if ((entries = diskfile_entries_take(&b->header)) == NULL)
+		goto out;
 
-		var->next = newvar;
+	/* 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;
 	}
 
-	result = config_write(b, key, &preg, value);
+	if ((error = config_write(b, name, entry->name, NULL, NULL)) < 0)
+		goto out;
 
-	git__free(key);
-	regfree(&preg);
+	if ((error =  config_refresh(cfg)) < 0)
+		goto out;
 
-	return result;
+out:
+	git_config_entries_free(entries);
+	git__free(key);
+	return error;
 }
 
-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)
 {
-	cvar_t *var;
 	diskfile_backend *b = (diskfile_backend *)cfg;
-	char *key;
+	git_config_entries *entries = NULL;
+	git_config_entry *entry = NULL;
+	regex_t preg = { 0 };
+	char *key = NULL;
 	int result;
-	khiter_t pos;
-
-	if ((result = normalize_name(name, &key)) < 0)
-		return result;
 
-	pos = git_strmap_lookup_index(b->values, key);
-	git__free(key);
+	if ((result = git_config__normalize_name(name, &key)) < 0)
+		goto out;
 
-	if (!git_strmap_valid_index(b->values, pos)) {
-		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;
 	}
 
-	var = git_strmap_value_at(b->values, pos);
+	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;
+	}
 
-	if (var->next != NULL) {
-		giterr_set(GITERR_CONFIG, "Cannot delete multivar with a single delete");
-		return -1;
+	if ((result = p_regcomp(&preg, regexp, REG_EXTENDED)) != 0) {
+		git_error_set_regex(&preg, result);
+		result = -1;
+		goto out;
 	}
 
-	git_strmap_delete_at(b->values, pos);
+	if ((result = config_write(b, name, key, &preg, NULL)) < 0)
+		goto out;
 
-	result = config_write(b, var->entry->name, NULL, NULL);
+	if ((result = config_refresh(cfg)) < 0)
+		goto out;
 
-	cvar_free(var);
+out:
+	git_config_entries_free(entries);
+	git__free(key);
+	regfree(&preg);
 	return result;
 }
 
-int git_config_file__ondisk(git_config_backend **out, const char *path)
+static int config_lock(git_config_backend *_cfg)
 {
-	diskfile_backend *backend;
-
-	backend = git__calloc(1, sizeof(diskfile_backend));
-	GITERR_CHECK_ALLOC(backend);
-
-	backend->parent.version = GIT_CONFIG_BACKEND_VERSION;
-
-	backend->file_path = git__strdup(path);
-	GITERR_CHECK_ALLOC(backend->file_path);
+	diskfile_backend *cfg = (diskfile_backend *) _cfg;
+	int error;
 
-	backend->parent.open = config_open;
-	backend->parent.get = config_get;
-	backend->parent.get_multivar = config_get_multivar;
-	backend->parent.set = config_set;
-	backend->parent.set_multivar = config_set_multivar;
-	backend->parent.del = config_delete;
-	backend->parent.foreach = file_foreach;
-	backend->parent.refresh = config_refresh;
-	backend->parent.free = backend_free;
+	if ((error = git_filebuf_open(&cfg->locked_buf, cfg->file.path, 0, GIT_CONFIG_FILE_MODE)) < 0)
+		return error;
 
-	*out = (git_config_backend *)backend;
+	error = git_futils_readbuffer(&cfg->locked_content, cfg->file.path);
+	if (error < 0 && error != GIT_ENOTFOUND) {
+		git_filebuf_cleanup(&cfg->locked_buf);
+		return error;
+	}
 
+	cfg->locked = true;
 	return 0;
+
 }
 
-static int cfg_getchar_raw(diskfile_backend *cfg)
+static int config_unlock(git_config_backend *_cfg, int success)
 {
-	int c;
-
-	c = *cfg->reader.read_ptr++;
+	diskfile_backend *cfg = (diskfile_backend *) _cfg;
+	int error = 0;
 
-	/*
-	Win 32 line breaks: if we find a \r\n sequence,
-	return only the \n as a newline
-	*/
-	if (c == '\r' && *cfg->reader.read_ptr == '\n') {
-		cfg->reader.read_ptr++;
-		c = '\n';
+	if (success) {
+		git_filebuf_write(&cfg->locked_buf, cfg->locked_content.ptr, cfg->locked_content.size);
+		error = git_filebuf_commit(&cfg->locked_buf);
 	}
 
-	if (c == '\n')
-		cfg->reader.line_number++;
-
-	if (c == 0) {
-		cfg->reader.eof = 1;
-		c = '\n';
-	}
+	git_filebuf_cleanup(&cfg->locked_buf);
+	git_buf_dispose(&cfg->locked_content);
+	cfg->locked = false;
 
-	return c;
+	return error;
 }
 
-#define SKIP_WHITESPACE (1 << 1)
-#define SKIP_COMMENTS (1 << 2)
-
-static int cfg_getchar(diskfile_backend *cfg_file, int flags)
+int git_config_backend_from_file(git_config_backend **out, const char *path)
 {
-	const int skip_whitespace = (flags & SKIP_WHITESPACE);
-	const int skip_comments = (flags & SKIP_COMMENTS);
-	int c;
-
-	assert(cfg_file->reader.read_ptr);
+	diskfile_backend *backend;
 
-	do c = cfg_getchar_raw(cfg_file);
-	while (skip_whitespace && git__isspace(c) &&
-	       !cfg_file->reader.eof);
+	backend = git__calloc(1, sizeof(diskfile_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);
+	GIT_ERROR_CHECK_ALLOC(backend->file.path);
+	git_array_init(backend->file.includes);
+
+	backend->header.parent.open = config_open;
+	backend->header.parent.get = config_get;
+	backend->header.parent.set = config_set;
+	backend->header.parent.set_multivar = config_set_multivar;
+	backend->header.parent.del = config_delete;
+	backend->header.parent.del_multivar = config_delete_multivar;
+	backend->header.parent.iterator = config_iterator_new;
+	backend->header.parent.snapshot = config_snapshot;
+	backend->header.parent.lock = config_lock;
+	backend->header.parent.unlock = config_unlock;
+	backend->header.parent.free = backend_free;
 
-	if (skip_comments && (c == '#' || c == ';')) {
-		do c = cfg_getchar_raw(cfg_file);
-		while (c != '\n');
-	}
+	*out = (git_config_backend *)backend;
 
-	return c;
+	return 0;
 }
 
-/*
- * Read the next char, but don't move the reading pointer.
- */
-static int cfg_peek(diskfile_backend *cfg, int flags)
+static int config_set_readonly(git_config_backend *cfg, const char *name, const char *value)
 {
-	void *old_read_ptr;
-	int old_lineno, old_eof;
-	int ret;
-
-	assert(cfg->reader.read_ptr);
-
-	old_read_ptr = cfg->reader.read_ptr;
-	old_lineno = cfg->reader.line_number;
-	old_eof = cfg->reader.eof;
+	GIT_UNUSED(cfg);
+	GIT_UNUSED(name);
+	GIT_UNUSED(value);
 
-	ret = cfg_getchar(cfg, flags);
-
-	cfg->reader.read_ptr = old_read_ptr;
-	cfg->reader.line_number = old_lineno;
-	cfg->reader.eof = old_eof;
-
-	return ret;
+	return config_error_readonly();
 }
 
-/*
- * Read and consume a line, returning it in newly-allocated memory.
- */
-static char *cfg_readline(diskfile_backend *cfg, bool skip_whitespace)
+static int config_set_multivar_readonly(
+	git_config_backend *cfg, const char *name, const char *regexp, const char *value)
 {
-	char *line = NULL;
-	char *line_src, *line_end;
-	size_t line_len;
+	GIT_UNUSED(cfg);
+	GIT_UNUSED(name);
+	GIT_UNUSED(regexp);
+	GIT_UNUSED(value);
 
-	line_src = cfg->reader.read_ptr;
+	return config_error_readonly();
+}
 
-	if (skip_whitespace) {
-		/* Skip empty empty lines */
-		while (git__isspace(*line_src))
-			++line_src;
-	}
+static int config_delete_multivar_readonly(git_config_backend *cfg, const char *name, const char *regexp)
+{
+	GIT_UNUSED(cfg);
+	GIT_UNUSED(name);
+	GIT_UNUSED(regexp);
 
-	line_end = strchr(line_src, '\n');
+	return config_error_readonly();
+}
 
-	/* no newline at EOF */
-	if (line_end == NULL)
-		line_end = strchr(line_src, 0);
+static int config_delete_readonly(git_config_backend *cfg, const char *name)
+{
+	GIT_UNUSED(cfg);
+	GIT_UNUSED(name);
 
-	line_len = line_end - line_src;
+	return config_error_readonly();
+}
 
-	line = git__malloc(line_len + 1);
-	if (line == NULL)
-		return NULL;
+static int config_lock_readonly(git_config_backend *_cfg)
+{
+	GIT_UNUSED(_cfg);
 
-	memcpy(line, line_src, line_len);
+	return config_error_readonly();
+}
 
-	do line[line_len] = '\0';
-	while (line_len-- > 0 && git__isspace(line[line_len]));
+static int config_unlock_readonly(git_config_backend *_cfg, int success)
+{
+	GIT_UNUSED(_cfg);
+	GIT_UNUSED(success);
 
-	if (*line_end == '\n')
-		line_end++;
+	return config_error_readonly();
+}
 
-	if (*line_end == '\0')
-		cfg->reader.eof = 1;
+static void backend_readonly_free(git_config_backend *_backend)
+{
+	diskfile_backend *backend = (diskfile_backend *)_backend;
 
-	cfg->reader.line_number++;
-	cfg->reader.read_ptr = line_end;
+	if (backend == NULL)
+		return;
 
-	return line;
+	git_config_entries_free(backend->header.entries);
+	git_mutex_free(&backend->header.values_mutex);
+	git__free(backend);
 }
 
-/*
- * Consume a line, without storing it anywhere
- */
-static void cfg_consume_line(diskfile_backend *cfg)
+static int config_readonly_open(git_config_backend *cfg, git_config_level_t level, const git_repository *repo)
 {
-	char *line_start, *line_end;
+	diskfile_readonly_backend *b = (diskfile_readonly_backend *) cfg;
+	diskfile_backend *src = b->snapshot_from;
+	diskfile_header *src_header = &src->header;
+	git_config_entries *entries;
+	int error;
 
-	line_start = cfg->reader.read_ptr;
-	line_end = strchr(line_start, '\n');
-	/* No newline at EOF */
-	if(line_end == NULL){
-		line_end = strchr(line_start, '\0');
-	}
+	if (!src_header->parent.readonly && (error = config_refresh(&src_header->parent)) < 0)
+		return error;
 
-	if (*line_end == '\n')
-		line_end++;
+	/* We're just copying data, don't care about the level or repo*/
+	GIT_UNUSED(level);
+	GIT_UNUSED(repo);
 
-	if (*line_end == '\0')
-		cfg->reader.eof = 1;
+	if ((entries = diskfile_entries_take(src_header)) == NULL)
+		return -1;
+	b->header.entries = entries;
 
-	cfg->reader.line_number++;
-	cfg->reader.read_ptr = line_end;
+	return 0;
 }
 
-GIT_INLINE(int) config_keychar(int c)
+static int config_snapshot(git_config_backend **out, git_config_backend *in)
 {
-	return isalnum(c) || c == '-';
-}
+	diskfile_readonly_backend *backend;
 
-static int parse_section_header_ext(diskfile_backend *cfg, const char *line, const char *base_name, char **section_name)
-{
-	int c, rpos;
-	char *first_quote, *last_quote;
-	git_buf buf = GIT_BUF_INIT;
-	int quote_marks;
-	/*
-	 * base_name is what came before the space. We should be at the
-	 * first quotation mark, except for now, line isn't being kept in
-	 * sync so we only really use it to calculate the length.
-	 */
+	backend = git__calloc(1, sizeof(diskfile_readonly_backend));
+	GIT_ERROR_CHECK_ALLOC(backend);
 
-	first_quote = strchr(line, '"');
-	last_quote = strrchr(line, '"');
+	backend->header.parent.version = GIT_CONFIG_BACKEND_VERSION;
+	git_mutex_init(&backend->header.values_mutex);
 
-	if (last_quote - first_quote == 0) {
-		set_parse_error(cfg, 0, "Missing closing quotation mark in section header");
-		return -1;
-	}
+	backend->snapshot_from = (diskfile_backend *) in;
 
-	git_buf_grow(&buf, strlen(base_name) + last_quote - first_quote + 2);
-	git_buf_printf(&buf, "%s.", base_name);
+	backend->header.parent.readonly = 1;
+	backend->header.parent.version = GIT_CONFIG_BACKEND_VERSION;
+	backend->header.parent.open = config_readonly_open;
+	backend->header.parent.get = config_get;
+	backend->header.parent.set = config_set_readonly;
+	backend->header.parent.set_multivar = config_set_multivar_readonly;
+	backend->header.parent.del = config_delete_readonly;
+	backend->header.parent.del_multivar = config_delete_multivar_readonly;
+	backend->header.parent.iterator = config_iterator_new;
+	backend->header.parent.lock = config_lock_readonly;
+	backend->header.parent.unlock = config_unlock_readonly;
+	backend->header.parent.free = backend_readonly_free;
 
-	rpos = 0;
-	quote_marks = 0;
+	*out = (git_config_backend *)backend;
+
+	return 0;
+}
 
-	line = first_quote;
-	c = line[rpos++];
+static int included_path(git_buf *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]);
 
-	/*
-	 * At the end of each iteration, whatever is stored in c will be
-	 * added to the string. In case of error, jump to out
-	 */
-	do {
-		if (quote_marks == 2) {
-			set_parse_error(cfg, rpos, "Unexpected text after closing quotes");
-			git_buf_free(&buf);
-			return -1;
-		}
+	return git_path_join_unrooted(out, path, dir, NULL);
+}
 
-		switch (c) {
-		case '"':
-			++quote_marks;
-			continue;
+/* Escape the values to write them to the file */
+static char *escape_value(const char *ptr)
+{
+	git_buf buf;
+	size_t len;
+	const char *esc;
 
-		case '\\':
-			c = line[rpos++];
+	assert(ptr);
 
-			switch (c) {
-			case '"':
-			case '\\':
-				break;
+	len = strlen(ptr);
+	if (!len)
+		return git__calloc(1, sizeof(char));
 
-			default:
-				set_parse_error(cfg, rpos, "Unsupported escape sequence");
-				git_buf_free(&buf);
-				return -1;
-			}
+	if (git_buf_init(&buf, len) < 0)
+		return NULL;
 
-		default:
-			break;
+	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]);
+		} else {
+			git_buf_putc(&buf, *ptr);
 		}
+		ptr++;
+	}
 
-		git_buf_putc(&buf, c);
-	} while ((c = line[rpos++]) != ']');
+	if (git_buf_oom(&buf))
+		return NULL;
 
-	*section_name = git_buf_detach(&buf);
-	return 0;
+	return git_buf_detach(&buf);
 }
 
-static int parse_section_header(diskfile_backend *cfg, char **section_out)
+static int parse_include(git_config_parser *reader,
+	diskfile_parse_state *parse_data, const char *file)
 {
-	char *name, *name_end;
-	int name_length, c, pos;
+	struct config_file *include;
+	git_buf path = GIT_BUF_INIT;
+	char *dir;
 	int result;
-	char *line;
-
-	line = cfg_readline(cfg, true);
-	if (line == NULL)
-		return -1;
 
-	/* find the end of the variable's name */
-	name_end = strchr(line, ']');
-	if (name_end == NULL) {
-		git__free(line);
-		set_parse_error(cfg, 0, "Missing ']' in section header");
-		return -1;
-	}
+	if (!file)
+		return 0;
 
-	name = (char *)git__malloc((size_t)(name_end - line) + 1);
-	GITERR_CHECK_ALLOC(name);
+	if ((result = git_path_dirname_r(&path, reader->file->path)) < 0)
+		return result;
 
-	name_length = 0;
-	pos = 0;
+	dir = git_buf_detach(&path);
+	result = included_path(&path, dir, file);
+	git__free(dir);
 
-	/* Make sure we were given a section header */
-	c = line[pos++];
-	assert(c == '[');
+	if (result < 0)
+		return result;
 
-	c = line[pos++];
+	include = git_array_alloc(reader->file->includes);
+	memset(include, 0, sizeof(*include));
+	git_array_init(include->includes);
+	include->path = git_buf_detach(&path);
 
-	do {
-		if (git__isspace(c)){
-			name[name_length] = '\0';
-			result = parse_section_header_ext(cfg, line, name, section_out);
-			git__free(line);
-			git__free(name);
-			return result;
-		}
+	result = config_read(parse_data->entries, parse_data->repo,
+		include, parse_data->level, parse_data->depth+1);
 
-		if (!config_keychar(c) && c != '.') {
-			set_parse_error(cfg, pos, "Unexpected character in header");
-			goto fail_parse;
-		}
+	if (result == GIT_ENOTFOUND) {
+		git_error_clear();
+		result = 0;
+	}
 
-		name[name_length++] = (char) tolower(c);
+	return result;
+}
 
-	} while ((c = line[pos++]) != ']');
+static int do_match_gitdir(
+	int *matches,
+	const git_repository *repo,
+	const char *cfg_file,
+	const char *value,
+	bool case_insensitive)
+{
+	git_buf path = GIT_BUF_INIT;
+	int error, fnmatch_flags;
+
+	if (value[0] == '.' && git_path_is_dirsep(value[1])) {
+		git_path_dirname_r(&path, cfg_file);
+		git_buf_joinpath(&path, path.ptr, value + 2);
+	} else if (value[0] == '~' && git_path_is_dirsep(value[1]))
+		git_sysdir_expand_global_file(&path, value + 1);
+	else if (!git_path_is_absolute(value))
+		git_buf_joinpath(&path, "**", value);
+	else
+		git_buf_sets(&path, value);
 
-	if (line[pos - 1] != ']') {
-		set_parse_error(cfg, pos, "Unexpected end of file");
-		goto fail_parse;
+	if (git_buf_oom(&path)) {
+		error = -1;
+		goto out;
 	}
 
-	git__free(line);
+	if (git_path_is_dirsep(value[strlen(value) - 1]))
+		git_buf_puts(&path, "**");
 
-	name[name_length] = 0;
-	*section_out = name;
+	fnmatch_flags = FNM_PATHNAME|FNM_LEADING_DIR;
+	if (case_insensitive)
+		fnmatch_flags |= FNM_IGNORECASE;
 
-	return 0;
+	if ((error = p_fnmatch(path.ptr, git_repository_path(repo), fnmatch_flags)) < 0)
+		goto out;
 
-fail_parse:
-	git__free(line);
-	git__free(name);
-	return -1;
+	*matches = (error == 0);
+
+out:
+	git_buf_dispose(&path);
+	return error;
 }
 
-static int skip_bom(diskfile_backend *cfg)
+static int conditional_match_gitdir(
+	int *matches,
+	const git_repository *repo,
+	const char *cfg_file,
+	const char *value)
 {
-	git_bom_t bom;
-	int bom_offset = git_buf_text_detect_bom(&bom,
-		&cfg->reader.buffer, cfg->reader.read_ptr - cfg->reader.buffer.ptr);
+	return do_match_gitdir(matches, repo, cfg_file, value, false);
+}
 
-	if (bom == GIT_BOM_UTF8)
-		cfg->reader.read_ptr += bom_offset;
+static int conditional_match_gitdir_i(
+	int *matches,
+	const git_repository *repo,
+	const char *cfg_file,
+	const char *value)
+{
+	return do_match_gitdir(matches, repo, cfg_file, value, true);
+}
 
-	/* TODO: reference implementation is pretty stupid with BoM */
+static const struct {
+	const char *prefix;
+	int (*matches)(int *matches, const git_repository *repo, const char *cfg, const char *value);
+} conditions[] = {
+	{ "gitdir:", conditional_match_gitdir },
+	{ "gitdir/i:", conditional_match_gitdir_i }
+};
 
-	return 0;
-}
+static int parse_conditional_include(git_config_parser *reader,
+	diskfile_parse_state *parse_data, const char *section, const char *file)
+{
+	char *condition;
+	size_t i;
+	int error = 0, matches;
 
-/*
-	(* basic types *)
-	digit = "0".."9"
-	integer = digit { digit }
-	alphabet = "a".."z" + "A" .. "Z"
+	if (!parse_data->repo || !file)
+		return 0;
 
-	section_char = alphabet | "." | "-"
-	extension_char = (* any character except newline *)
-	any_char = (* any character *)
-	variable_char = "alphabet" | "-"
+	condition = git__substrdup(section + strlen("includeIf."),
+				   strlen(section) - strlen("includeIf.") - strlen(".path"));
 
+	for (i = 0; i < ARRAY_SIZE(conditions); i++) {
+		if (git__prefixcmp(condition, conditions[i].prefix))
+			continue;
 
-	(* actual grammar *)
-	config = { section }
+		if ((error = conditions[i].matches(&matches,
+						   parse_data->repo,
+						   parse_data->file_path,
+						   condition + strlen(conditions[i].prefix))) < 0)
+			break;
 
-	section = header { definition }
+		if (matches)
+			error = parse_include(reader, parse_data, file);
 
-	header = "[" section [subsection | subsection_ext] "]"
+		break;
+	}
 
-	subsection = "." section
-	subsection_ext = "\"" extension "\""
+	git__free(condition);
+	return error;
+}
 
-	section = section_char { section_char }
-	extension = extension_char { extension_char }
+static int read_on_variable(
+	git_config_parser *reader,
+	const char *current_section,
+	const char *var_name,
+	const char *var_value,
+	const char *line,
+	size_t line_len,
+	void *data)
+{
+	diskfile_parse_state *parse_data = (diskfile_parse_state *)data;
+	git_buf buf = GIT_BUF_INIT;
+	git_config_entry *entry;
+	const char *c;
+	int result = 0;
 
-	definition = variable_name ["=" variable_value] "\n"
+	GIT_UNUSED(line);
+	GIT_UNUSED(line_len);
 
-	variable_name = variable_char { variable_char }
-	variable_value = string | boolean | integer
+	if (current_section) {
+		/* TODO: Once warnings lang, we should likely warn
+		 * 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, '.');
+	}
 
-	string = quoted_string | plain_string
-	quoted_string = "\"" plain_string "\""
-	plain_string = { any_char }
+	for (c = var_name; *c; c++)
+		git_buf_putc(&buf, git__tolower(*c));
 
-	boolean = boolean_true | boolean_false
-	boolean_true = "yes" | "1" | "true" | "on"
-	boolean_false = "no" | "0" | "false" | "off"
-*/
+	if (git_buf_oom(&buf))
+		return -1;
 
-static int strip_comments(char *line, int in_quotes)
-{
-	int quote_count = in_quotes;
-	char *ptr;
+	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;
 
-	for (ptr = line; *ptr; ++ptr) {
-		if (ptr[0] == '"' && ptr > line && ptr[-1] != '\\')
-			quote_count++;
+	if ((result = git_config_entries_append(parse_data->entries, entry)) < 0)
+		return result;
 
-		if ((ptr[0] == ';' || ptr[0] == '#') && (quote_count % 2) == 0) {
-			ptr[0] = '\0';
-			break;
-		}
-	}
+	result = 0;
 
-	/* skip any space at the end */
-	if (ptr > line && git__isspace(ptr[-1])) {
-		ptr--;
-	}
-	ptr[0] = '\0';
+	/* Add or append the new config option */
+	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,
+						   entry->name, entry->value);
 
-	return quote_count;
+	return result;
 }
 
-static int config_parse(diskfile_backend *cfg_file, git_config_level_t level)
+static int config_read(
+	git_config_entries *entries,
+	const git_repository *repo,
+	git_config_file *file,
+	git_config_level_t level,
+	int depth)
 {
-	int c;
-	char *current_section = NULL;
-	char *var_name;
-	char *var_value;
-	cvar_t *var, *existing;
-	git_buf buf = GIT_BUF_INIT;
-	int result = 0;
-	khiter_t pos;
-
-	/* Initialize the reading position */
-	cfg_file->reader.read_ptr = cfg_file->reader.buffer.ptr;
-	cfg_file->reader.eof = 0;
-
-	/* If the file is empty, there's nothing for us to do */
-	if (*cfg_file->reader.read_ptr == '\0')
-		return 0;
+	diskfile_parse_state parse_data;
+	git_config_parser reader;
+	git_buf contents = GIT_BUF_INIT;
+	int error;
 
-	skip_bom(cfg_file);
+	if (depth >= MAX_INCLUDE_DEPTH) {
+		git_error_set(GIT_ERROR_CONFIG, "maximum config include depth reached");
+		return -1;
+	}
 
-	while (result == 0 && !cfg_file->reader.eof) {
+	if ((error = git_futils_readbuffer(&contents, file->path)) < 0)
+		goto out;
 
-		c = cfg_peek(cfg_file, SKIP_WHITESPACE);
+	git_parse_ctx_init(&reader.ctx, contents.ptr, contents.size);
 
-		switch (c) {
-		case '\n': /* EOF when peeking, set EOF in the reader to exit the loop */
-			cfg_file->reader.eof = 1;
-			break;
+	if ((error = git_hash_buf(&file->checksum, contents.ptr, contents.size)) < 0)
+		goto out;
 
-		case '[': /* section header, new section begins */
-			git__free(current_section);
-			current_section = NULL;
-			result = parse_section_header(cfg_file, &current_section);
-			break;
+	/* Initialize the reading position */
+	reader.file = file;
+	git_parse_ctx_init(&reader.ctx, contents.ptr, contents.size);
 
-		case ';':
-		case '#':
-			cfg_consume_line(cfg_file);
-			break;
+	/* If the file is empty, there's nothing for us to do */
+	if (!reader.ctx.content || *reader.ctx.content == '\0')
+		goto out;
 
-		default: /* assume variable declaration */
-			result = parse_variable(cfg_file, &var_name, &var_value);
-			if (result < 0)
-				break;
-
-			var = git__malloc(sizeof(cvar_t));
-			GITERR_CHECK_ALLOC(var);
-			memset(var, 0x0, sizeof(cvar_t));
-			var->entry = git__malloc(sizeof(git_config_entry));
-			GITERR_CHECK_ALLOC(var->entry);
-			memset(var->entry, 0x0, sizeof(git_config_entry));
-
-			git__strtolower(var_name);
-			git_buf_printf(&buf, "%s.%s", current_section, var_name);
-			git__free(var_name);
-
-			if (git_buf_oom(&buf))
-				return -1;
-
-			var->entry->name = git_buf_detach(&buf);
-			var->entry->value = var_value;
-			var->entry->level = level;
-
-			/* Add or append the new config option */
-			pos = git_strmap_lookup_index(cfg_file->values, var->entry->name);
-			if (!git_strmap_valid_index(cfg_file->values, pos)) {
-				git_strmap_insert(cfg_file->values, var->entry->name, var, result);
-				if (result < 0)
-					break;
-				result = 0;
-			} else {
-				existing = git_strmap_value_at(cfg_file->values, pos);
-				while (existing->next != NULL) {
-					existing = existing->next;
-				}
-				existing->next = var;
-			}
+	parse_data.repo = repo;
+	parse_data.file_path = file->path;
+	parse_data.entries = entries;
+	parse_data.level = level;
+	parse_data.depth = depth;
 
-			break;
-		}
-	}
+	error = git_config_parse(&reader, NULL, read_on_variable, NULL, NULL, &parse_data);
 
-	git__free(current_section);
-	return result;
+out:
+	git_buf_dispose(&contents);
+	return error;
 }
 
-static int write_section(git_filebuf *file, const char *key)
+static int write_section(git_buf *fbuf, const char *key)
 {
 	int result;
 	const char *dot;
@@ -1067,7 +911,7 @@ static int write_section(git_filebuf *file, 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);
 	}
@@ -1076,408 +920,288 @@ static int write_section(git_filebuf *file, const char *key)
 	if (git_buf_oom(&buf))
 		return -1;
 
-	result = git_filebuf_write(file, git_buf_cstr(&buf), buf.size);
-	git_buf_free(&buf);
+	result = git_buf_put(fbuf, git_buf_cstr(&buf), buf.size);
+	git_buf_dispose(&buf);
 
 	return result;
 }
 
-/*
- * This is pretty much the parsing, except we write out anything we don't have
- */
-static int config_write(diskfile_backend *cfg, const char *key, const regex_t *preg, const char* value)
+static const char *quotes_for_value(const char *value)
 {
-	int result, c;
-	int section_matches = 0, last_section_matched = 0, preg_replaced = 0, write_trailer = 0;
-	const char *pre_end = NULL, *post_start = NULL, *data_start;
-	char *current_section = NULL, *section, *name, *ldot;
-	git_filebuf file = GIT_FILEBUF_INIT;
+	const char *ptr;
 
-	/* We need to read in our own config file */
-	result = git_futils_readbuffer(&cfg->reader.buffer, cfg->file_path);
+	if (value[0] == ' ' || value[0] == '\0')
+		return "\"";
 
-	/* Initialise the reading position */
-	if (result == GIT_ENOTFOUND) {
-		cfg->reader.read_ptr = NULL;
-		cfg->reader.eof = 1;
-		data_start = NULL;
-		git_buf_clear(&cfg->reader.buffer);
-	} else if (result == 0) {
-		cfg->reader.read_ptr = cfg->reader.buffer.ptr;
-		cfg->reader.eof = 0;
-		data_start = cfg->reader.read_ptr;
-	} else {
-		return -1; /* OS error when reading the file */
+	for (ptr = value; *ptr; ++ptr) {
+		if (*ptr == ';' || *ptr == '#')
+			return "\"";
 	}
 
-	/* Lock the file */
-	if (git_filebuf_open(&file, cfg->file_path, 0) < 0)
-		return -1;
-
-	skip_bom(cfg);
-	ldot = strrchr(key, '.');
-	name = ldot + 1;
-	section = git__strndup(key, ldot - key);
-
-	while (!cfg->reader.eof) {
-		c = cfg_peek(cfg, SKIP_WHITESPACE);
+	if (ptr[-1] == ' ')
+		return "\"";
 
-		if (c == '\0') { /* We've arrived at the end of the file */
-			break;
+	return "";
+}
 
-		} else if (c == '[') { /* section header, new section begins */
-			/*
-			 * We set both positions to the current one in case we
-			 * need to add a variable to the end of a section. In that
-			 * case, we want both variables to point just before the
-			 * new section. If we actually want to replace it, the
-			 * default case will take care of updating them.
-			 */
-			pre_end = post_start = cfg->reader.read_ptr;
-
-			git__free(current_section);
-			current_section = NULL;
-			if (parse_section_header(cfg, &current_section) < 0)
-				goto rewrite_fail;
-
-			/* Keep track of when it stops matching */
-			last_section_matched = section_matches;
-			section_matches = !strcmp(current_section, section);
-		}
+struct write_data {
+	git_buf *buf;
+	git_buf buffered_comment;
+	unsigned int in_section : 1,
+		preg_replaced : 1;
+	const char *orig_section;
+	const char *section;
+	const char *orig_name;
+	const char *name;
+	const regex_t *preg;
+	const char *value;
+};
+
+static int write_line_to(git_buf *buf, const char *line, size_t line_len)
+{
+	int result = git_buf_put(buf, line, line_len);
 
-		else if (c == ';' || c == '#') {
-			cfg_consume_line(cfg);
-		}
+	if (!result && line_len && line[line_len-1] != '\n')
+		result = git_buf_printf(buf, "\n");
 
-		else {
-			/*
-			 * If the section doesn't match, but the last section did,
-			 * it means we need to add a variable (so skip the line
-			 * otherwise). If both the section and name match, we need
-			 * to overwrite the variable (so skip the line
-			 * otherwise). pre_end needs to be updated each time so we
-			 * don't loose that information, but we only need to
-			 * update post_start if we're going to use it in this
-			 * iteration.
-			 */
-			if (!section_matches) {
-				if (!last_section_matched) {
-					cfg_consume_line(cfg);
-					continue;
-				}
-			} else {
-				int has_matched = 0;
-				char *var_name, *var_value;
-
-				pre_end = cfg->reader.read_ptr;
-				if (parse_variable(cfg, &var_name, &var_value) < 0)
-					goto rewrite_fail;
-
-				/* First try to match the name of the variable */
-				if (strcasecmp(name, var_name) == 0)
-					has_matched = 1;
-
-				/* If the name matches, and we have a regex to match the
-				 * value, try to match it */
-				if (has_matched && preg != NULL)
-					has_matched = (regexec(preg, var_value, 0, NULL, 0) == 0);
-
-				git__free(var_name);
-				git__free(var_value);
-
-				/* if there is no match, keep going */
-				if (!has_matched)
-					continue;
-
-				post_start = cfg->reader.read_ptr;
-			}
-
-			/* We've found the variable we wanted to change, so
-			 * write anything up to it */
-			git_filebuf_write(&file, data_start, pre_end - data_start);
-			preg_replaced = 1;
-
-			/* Then replace the variable. If the value is NULL, it
-			 * means we want to delete it, so don't write anything. */
-			if (value != NULL) {
-				git_filebuf_printf(&file, "\t%s = %s\n", name, value);
-			}
-
-			/* multiline variable? we need to keep reading lines to match */
-			if (preg != NULL) {
-				data_start = post_start;
-				continue;
-			}
-
-			write_trailer = 1;
-			break; /* break from the loop */
-		}
-	}
+	return result;
+}
 
-	/*
-	 * Being here can mean that
-	 *
-	 * 1) our section is the last one in the file and we're
-	 * adding a variable
-	 *
-	 * 2) we didn't find a section for us so we need to create it
-	 * ourselves.
-	 *
-	 * 3) we're setting a multivar with a regex, which means we
-	 * continue to search for matching values
-	 *
-	 * In the last case, if we've already replaced a value, we
-	 * want to write the rest of the file. Otherwise we need to write
-	 * out the whole file and then the new variable.
-	 */
-	if (write_trailer) {
-		/* Write out rest of the file */
-		git_filebuf_write(&file, post_start, cfg->reader.buffer.size - (post_start - data_start));
-	} else {
-		if (preg_replaced) {
-			git_filebuf_printf(&file, "\n%s", data_start);
-		} else {
-			git_filebuf_write(&file, cfg->reader.buffer.ptr, cfg->reader.buffer.size);
-
-			/* And now if we just need to add a variable */
-			if (!section_matches && write_section(&file, section) < 0)
-				goto rewrite_fail;
-
-			/* Sanity check: if we are here, and value is NULL, that means that somebody
-			 * touched the config file after our intial read. We should probably assert()
-			 * this, but instead we'll handle it gracefully with an error. */
-			if (value == NULL) {
-				giterr_set(GITERR_CONFIG,
-					"Race condition when writing a config file (a cvar has been removed)");
-				goto rewrite_fail;
-			}
-
-			/* If we are here, there is at least a section line */
-			if (cfg->reader.buffer.size > 0 && *(cfg->reader.buffer.ptr + cfg->reader.buffer.size - 1) != '\n')
-				git_filebuf_write(&file, "\n", 1);
-
-			git_filebuf_printf(&file, "\t%s = %s\n", name, value);
-		}
-	}
+static int write_line(struct write_data *write_data, const char *line, size_t line_len)
+{
+	return write_line_to(write_data->buf, line, line_len);
+}
 
-	git__free(section);
-	git__free(current_section);
+static int write_value(struct write_data *write_data)
+{
+	const char *q;
+	int result;
 
-	/* refresh stats - if this errors, then commit will error too */
-	(void)git_filebuf_stats(&cfg->file_mtime, &cfg->file_size, &file);
+	q = quotes_for_value(write_data->value);
+	result = git_buf_printf(write_data->buf,
+		"\t%s = %s%s%s\n", write_data->orig_name, q, write_data->value, q);
 
-	result = git_filebuf_commit(&file, GIT_CONFIG_FILE_MODE);
-	git_buf_free(&cfg->reader.buffer);
+	/* If we are updating a single name/value, we're done.  Setting `value`
+	 * to `NULL` will prevent us from trying to write it again later (in
+	 * `write_on_section`) if we see the same section repeated.
+	 */
+	if (!write_data->preg)
+		write_data->value = NULL;
 
 	return result;
-
-rewrite_fail:
-	git__free(section);
-	git__free(current_section);
-
-	git_filebuf_cleanup(&file);
-	git_buf_free(&cfg->reader.buffer);
-	return -1;
 }
 
-static const char *escapes = "ntb\"\\";
-static const char *escaped = "\n\t\b\"\\";
-
-/* Escape the values to write them to the file */
-static char *escape_value(const char *ptr)
+static int write_on_section(
+	git_config_parser *reader,
+	const char *current_section,
+	const char *line,
+	size_t line_len,
+	void *data)
 {
-	git_buf buf = GIT_BUF_INIT;
-	size_t len;
-	const char *esc;
+	struct write_data *write_data = (struct write_data *)data;
+	int result = 0;
 
-	assert(ptr);
+	GIT_UNUSED(reader);
 
-	len = strlen(ptr);
-	git_buf_grow(&buf, len);
+	/* If we were previously in the correct section (but aren't anymore)
+	 * and haven't written our value (for a simple name/value set, not
+	 * a multivar), then append it to the end of the section before writing
+	 * the new one.
+	 */
+	if (write_data->in_section && !write_data->preg && write_data->value)
+		result = write_value(write_data);
 
-	while (*ptr != '\0') {
-		if ((esc = strchr(escaped, *ptr)) != NULL) {
-			git_buf_putc(&buf, '\\');
-			git_buf_putc(&buf, escapes[esc - escaped]);
-		} else {
-			git_buf_putc(&buf, *ptr);
-		}
-		ptr++;
-	}
+	write_data->in_section = strcmp(current_section, write_data->section) == 0;
 
-	if (git_buf_oom(&buf)) {
-		git_buf_free(&buf);
-		return NULL;
+	/*
+	 * 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);
 	}
 
-	return git_buf_detach(&buf);
+	if (!result)
+		result = write_line(write_data, line, line_len);
+
+	return result;
 }
 
-/* '\"' -> '"' etc */
-static char *fixup_line(const char *ptr, int quote_count)
+static int write_on_variable(
+	git_config_parser *reader,
+	const char *current_section,
+	const char *var_name,
+	const char *var_value,
+	const char *line,
+	size_t line_len,
+	void *data)
 {
-	char *str = git__malloc(strlen(ptr) + 1);
-	char *out = str, *esc;
+	struct write_data *write_data = (struct write_data *)data;
+	bool has_matched = false;
+	int error;
 
-	if (str == NULL)
-		return NULL;
+	GIT_UNUSED(reader);
+	GIT_UNUSED(current_section);
 
-	while (*ptr != '\0') {
-		if (*ptr == '"') {
-			quote_count++;
-		} else if (*ptr != '\\') {
-			*out++ = *ptr;
-		} else {
-			/* backslash, check the next char */
-			ptr++;
-			/* if we're at the end, it's a multiline, so keep the backslash */
-			if (*ptr == '\0') {
-				*out++ = '\\';
-				goto out;
-			}
-			if ((esc = strchr(escapes, *ptr)) != NULL) {
-				*out++ = escaped[esc - escapes];
-			} else {
-				git__free(str);
-				giterr_set(GITERR_CONFIG, "Invalid escape at %s", ptr);
-				return NULL;
-			}
-		}
-		ptr++;
-	}
+	/*
+	 * 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)
+		return error;
 
-out:
-	*out = '\0';
+	git_buf_clear(&write_data->buffered_comment);
 
-	return str;
-}
+	/* See if we are to update this name/value pair; first examine name */
+	if (write_data->in_section &&
+		strcasecmp(write_data->name, var_name) == 0)
+		has_matched = true;
 
-static int is_multiline_var(const char *str)
-{
-	int count = 0;
-	const char *end = str + strlen(str);
-	while (end > str && end[-1] == '\\') {
-		count++;
-		end--;
-	}
+	/* If we have a regex to match the value, see if it matches */
+	if (has_matched && write_data->preg != NULL)
+		has_matched = (regexec(write_data->preg, var_value, 0, NULL, 0) == 0);
 
-	/* An odd number means last backslash wasn't escaped, so it's multiline */
-	return (end > str) && (count & 1);
-}
+	/* If this isn't the name/value we're looking for, simply dump the
+	 * existing data back out and continue on.
+	 */
+	if (!has_matched)
+		return write_line(write_data, line, line_len);
 
-static int parse_multiline_variable(diskfile_backend *cfg, git_buf *value, int in_quotes)
-{
-	char *line = NULL, *proc_line = NULL;
-	int quote_count;
+	write_data->preg_replaced = 1;
 
-	/* Check that the next line exists */
-	line = cfg_readline(cfg, false);
-	if (line == NULL)
-		return -1;
+	/* If value is NULL, we are deleting this value; write nothing. */
+	if (!write_data->value)
+		return 0;
 
-	/* We've reached the end of the file, there is input missing */
-	if (line[0] == '\0') {
-		set_parse_error(cfg, 0, "Unexpected end of file while parsing multine var");
-		git__free(line);
-		return -1;
-	}
+	return write_value(write_data);
+}
 
-	quote_count = strip_comments(line, !!in_quotes);
+static int write_on_comment(git_config_parser *reader, const char *line, size_t line_len, void *data)
+{
+	struct write_data *write_data;
 
-	/* If it was just a comment, pretend it didn't exist */
-	if (line[0] == '\0') {
-		git__free(line);
-		return parse_multiline_variable(cfg, value, quote_count);
-		/* TODO: unbounded recursion. This **could** be exploitable */
-	}
+	GIT_UNUSED(reader);
+
+	write_data = (struct write_data *)data;
+	return write_line_to(&write_data->buffered_comment, line, line_len);
+}
 
-	/* Drop the continuation character '\': to closely follow the UNIX
-	 * standard, this character **has** to be last one in the buf, with
-	 * no whitespace after it */
-	assert(is_multiline_var(value->ptr));
-	git_buf_truncate(value, git_buf_len(value) - 1);
+static int write_on_eof(
+	git_config_parser *reader, const char *current_section, void *data)
+{
+	struct write_data *write_data = (struct write_data *)data;
+	int result = 0;
 
-	proc_line = fixup_line(line, in_quotes);
-	if (proc_line == NULL) {
-		git__free(line);
-		return -1;
-	}
-	/* add this line to the multiline var */
-	git_buf_puts(value, proc_line);
-	git__free(line);
-	git__free(proc_line);
+	GIT_UNUSED(reader);
 
 	/*
-	 * If we need to continue reading the next line, let's just
-	 * keep putting stuff in the buffer
+	 * If we've buffered comments when reaching EOF, make sure to dump them.
 	 */
-	if (is_multiline_var(value->ptr))
-		return parse_multiline_variable(cfg, value, quote_count);
+	if ((result = git_buf_put(write_data->buf, write_data->buffered_comment.ptr, write_data->buffered_comment.size)) < 0)
+		return result;
 
-	return 0;
-}
+	/* If we are at the EOF and have not written our value (again, for a
+	 * simple name/value set, not a multivar) then we have never seen the
+	 * section in question and should create a new section and write the
+	 * value.
+	 */
+	if ((!write_data->preg || !write_data->preg_replaced) && write_data->value) {
+		/* write the section header unless we're already in it */
+		if (!current_section || strcmp(current_section, write_data->section))
+			result = write_section(write_data->buf, write_data->orig_section);
 
-static int parse_variable(diskfile_backend *cfg, char **var_name, char **var_value)
-{
-	const char *var_end = NULL;
-	const char *value_start = NULL;
-	char *line;
-	int quote_count;
+		if (!result)
+			result = write_value(write_data);
+	}
 
-	line = cfg_readline(cfg, true);
-	if (line == NULL)
-		return -1;
+	return result;
+}
 
-	quote_count = strip_comments(line, 0);
+/*
+ * This is pretty much the parsing, except we write out anything we don't have
+ */
+static int config_write(diskfile_backend *cfg, const char *orig_key, const char *key, const regex_t *preg, const char* value)
+{
+	int result;
+	char *orig_section, *section, *orig_name, *name, *ldot;
+	git_filebuf file = GIT_FILEBUF_INIT;
+	git_buf buf = GIT_BUF_INIT, contents = GIT_BUF_INIT;
+	git_config_parser reader;
+	struct write_data write_data;
 
-	var_end = strchr(line, '=');
+	memset(&reader, 0, sizeof(reader));
+	reader.file = &cfg->file;
 
-	if (var_end == NULL)
-		var_end = strchr(line, '\0');
-	else
-		value_start = var_end + 1;
+	if (cfg->locked) {
+		result = git_buf_puts(&contents, git_buf_cstr(&cfg->locked_content));
+	} else {
+		/* Lock the file */
+		if ((result = git_filebuf_open(
+			     &file, cfg->file.path, GIT_FILEBUF_HASH_CONTENTS, GIT_CONFIG_FILE_MODE)) < 0) {
+			git_buf_dispose(&contents);
+			return result;
+		}
 
-	do var_end--;
-	while (var_end>line && git__isspace(*var_end));
+		/* We need to read in our own config file */
+		result = git_futils_readbuffer(&contents, cfg->file.path);
+	}
 
-	*var_name = git__strndup(line, var_end - line + 1);
-	GITERR_CHECK_ALLOC(*var_name);
+	/* Initialise the reading position */
+	if (result == 0 || result == GIT_ENOTFOUND) {
+		git_parse_ctx_init(&reader.ctx, contents.ptr, contents.size);
+	} else {
+		git_filebuf_cleanup(&file);
+		return -1; /* OS error when reading the file */
+	}
 
-	/* If there is no value, boolean true is assumed */
-	*var_value = NULL;
+	ldot = strrchr(key, '.');
+	name = ldot + 1;
+	section = git__strndup(key, ldot - key);
+	GIT_ERROR_CHECK_ALLOC(section);
+
+	ldot = strrchr(orig_key, '.');
+	orig_name = ldot + 1;
+	orig_section = git__strndup(orig_key, ldot - orig_key);
+	GIT_ERROR_CHECK_ALLOC(orig_section);
+
+	write_data.buf = &buf;
+	git_buf_init(&write_data.buffered_comment, 0);
+	write_data.orig_section = orig_section;
+	write_data.section = section;
+	write_data.in_section = 0;
+	write_data.preg_replaced = 0;
+	write_data.orig_name = orig_name;
+	write_data.name = name;
+	write_data.preg = preg;
+	write_data.value = value;
+
+	result = git_config_parse(&reader,
+		write_on_section,
+		write_on_variable,
+		write_on_comment,
+		write_on_eof,
+		&write_data);
+	git__free(section);
+	git__free(orig_section);
+	git_buf_dispose(&write_data.buffered_comment);
 
-	/*
-	 * Now, let's try to parse the value
-	 */
-	if (value_start != NULL) {
-		while (git__isspace(value_start[0]))
-			value_start++;
-
-		if (is_multiline_var(value_start)) {
-			git_buf multi_value = GIT_BUF_INIT;
-			char *proc_line = fixup_line(value_start, 0);
-			GITERR_CHECK_ALLOC(proc_line);
-			git_buf_puts(&multi_value, proc_line);
-			git__free(proc_line);
-			if (parse_multiline_variable(cfg, &multi_value, quote_count) < 0 || git_buf_oom(&multi_value)) {
-				git__free(*var_name);
-				git__free(line);
-				git_buf_free(&multi_value);
-				return -1;
-			}
-
-			*var_value = git_buf_detach(&multi_value);
+	if (result < 0) {
+		git_filebuf_cleanup(&file);
+		goto done;
+	}
 
-		}
-		else if (value_start[0] != '\0') {
-			*var_value = fixup_line(value_start, 0);
-			GITERR_CHECK_ALLOC(*var_value);
-		} else { /* equals sign but missing rhs */
-			*var_value = git__strdup("");
-			GITERR_CHECK_ALLOC(*var_value);
-		}
+	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);
+	} else {
+		git_filebuf_write(&file, git_buf_cstr(&buf), git_buf_len(&buf));
+		result = git_filebuf_commit(&file);
 	}
 
-	git__free(line);
-	return 0;
+done:
+	git_buf_dispose(&buf);
+	git_buf_dispose(&contents);
+	git_parse_ctx_clear(&reader.ctx);
+	return result;
 }