rugged 0.26.7 → 0.27.0

data/vendor/libgit2/src/checkout.h

@@ -7,6 +7,8 @@
 #ifndef INCLUDE_checkout_h__
 #define INCLUDE_checkout_h__
 
+#include "common.h"
+
 #include "git2/checkout.h"
 #include "iterator.h"
 

data/vendor/libgit2/src/cherrypick.c

@@ -6,6 +6,7 @@
 */
 
 #include "common.h"
+
 #include "repository.h"
 #include "filebuf.h"
 #include "merge.h"

data/vendor/libgit2/src/clone.c

@@ -5,6 +5,8 @@
  * a Linking Exception. For full terms see the included COPYING file.
  */
 
+#include "clone.h"
+
 #include <assert.h>
 
 #include "git2/clone.h"
@@ -16,7 +18,6 @@
 #include "git2/commit.h"
 #include "git2/tree.h"
 
-#include "common.h"
 #include "remote.h"
 #include "fileops.h"
 #include "refs.h"

data/vendor/libgit2/src/clone.h

@@ -7,6 +7,10 @@
 #ifndef INCLUDE_clone_h__
 #define INCLUDE_clone_h__
 
+#include "common.h"
+
+#include "git2/clone.h"
+
 extern int git_clone__should_clone_local(const char *url, git_clone_local_t local);
 
 #endif

data/vendor/libgit2/src/commit.c

@@ -5,13 +5,14 @@
  * a Linking Exception. For full terms see the included COPYING file.
  */
 
+#include "commit.h"
+
 #include "git2/common.h"
 #include "git2/object.h"
 #include "git2/repository.h"
 #include "git2/signature.h"
 #include "git2/sys/commit.h"
 
-#include "common.h"
 #include "odb.h"
 #include "commit.h"
 #include "signature.h"

data/vendor/libgit2/src/commit.h

@@ -7,6 +7,8 @@
 #ifndef INCLUDE_commit_h__
 #define INCLUDE_commit_h__
 
+#include "common.h"
+
 #include "git2/commit.h"
 #include "tree.h"
 #include "repository.h"

data/vendor/libgit2/src/commit_list.c

@@ -6,7 +6,7 @@
  */
 
 #include "commit_list.h"
-#include "common.h"
+
 #include "revwalk.h"
 #include "pool.h"
 #include "odb.h"

data/vendor/libgit2/src/commit_list.h

@@ -7,6 +7,8 @@
 #ifndef INCLUDE_commit_list_h__
 #define INCLUDE_commit_list_h__
 
+#include "common.h"
+
 #include "git2/oid.h"
 
 #define PARENT1  (1 << 0)

data/vendor/libgit2/src/common.h

@@ -7,6 +7,10 @@
 #ifndef INCLUDE_common_h__
 #define INCLUDE_common_h__
 
+#ifndef LIBGIT2_NO_FEATURES_H
+# include "git2/sys/features.h"
+#endif
+
 #include "git2/common.h"
 #include "cc-compat.h"
 
@@ -47,10 +51,6 @@
 # ifdef GIT_THREADS
 #	include "win32/thread.h"
 # endif
-# if defined(GIT_MSVC_CRTDBG)
-#   include "win32/w32_stack.h"
-#   include "win32/w32_crtdbg_stacktrace.h"
-# endif
 
 #else
 
@@ -230,6 +230,12 @@ GIT_INLINE(void) git__init_structure(void *structure, size_t len, unsigned int v
 		GIT_ADD_SIZET_OVERFLOW(out, *(out), three) || \
 		GIT_ADD_SIZET_OVERFLOW(out, *(out), four)) { return -1; }
 
+#define GITERR_CHECK_ALLOC_ADD5(out, one, two, three, four, five) \
+	if (GIT_ADD_SIZET_OVERFLOW(out, one, two) || \
+		GIT_ADD_SIZET_OVERFLOW(out, *(out), three) || \
+		GIT_ADD_SIZET_OVERFLOW(out, *(out), four) || \
+		GIT_ADD_SIZET_OVERFLOW(out, *(out), five)) { return -1; }
+
 /** Check for multiplicative overflow, failing if it would occur. */
 #define GITERR_CHECK_ALLOC_MULTIPLY(out, nelem, elsize) \
 	if (GIT_MULTIPLY_SIZET_OVERFLOW(out, nelem, elsize)) { return -1; }
@@ -238,4 +244,4 @@ GIT_INLINE(void) git__init_structure(void *structure, size_t len, unsigned int v
 
 #include "util.h"
 
-#endif /* INCLUDE_common_h__ */
+#endif

data/vendor/libgit2/src/config.c

@@ -5,9 +5,9 @@
  * a Linking Exception. For full terms see the included COPYING file.
  */
 
-#include "common.h"
-#include "sysdir.h"
 #include "config.h"
+
+#include "sysdir.h"
 #include "git2/config.h"
 #include "git2/sys/config.h"
 #include "vector.h"
@@ -99,6 +99,7 @@ int git_config_add_file_ondisk(
 	git_config *cfg,
 	const char *path,
 	git_config_level_t level,
+	const git_repository *repo,
 	int force)
 {
 	git_config_backend *file = NULL;
@@ -116,7 +117,7 @@ int git_config_add_file_ondisk(
 	if (git_config_file__ondisk(&file, path) < 0)
 		return -1;
 
-	if ((res = git_config_add_backend(cfg, file, level, force)) < 0) {
+	if ((res = git_config_add_backend(cfg, file, level, repo, force)) < 0) {
 		/*
 		 * free manually; the file is not owned by the config
 		 * instance yet and will not be freed on cleanup
@@ -138,7 +139,7 @@ int git_config_open_ondisk(git_config **out, const char *path)
 	if (git_config_new(&config) < 0)
 		return -1;
 
-	if ((error = git_config_add_file_ondisk(config, path, GIT_CONFIG_LEVEL_LOCAL, 0)) < 0)
+	if ((error = git_config_add_file_ondisk(config, path, GIT_CONFIG_LEVEL_LOCAL, NULL, 0)) < 0)
 		git_config_free(config);
 	else
 		*out = config;
@@ -164,7 +165,7 @@ int git_config_snapshot(git_config **out, git_config *in)
 		if ((error = internal->file->snapshot(&b, internal->file)) < 0)
 			break;
 
-		if ((error = git_config_add_backend(config, b, internal->level, 0)) < 0) {
+		if ((error = git_config_add_backend(config, b, internal->level, NULL, 0)) < 0) {
 			b->free(b);
 			break;
 		}
@@ -307,6 +308,7 @@ int git_config_add_backend(
 	git_config *cfg,
 	git_config_backend *file,
 	git_config_level_t level,
+	const git_repository *repo,
 	int force)
 {
 	file_internal *internal;
@@ -316,7 +318,7 @@ int git_config_add_backend(
 
 	GITERR_CHECK_VERSION(file, GIT_CONFIG_BACKEND_VERSION, "git_config_backend");
 
-	if ((result = file->open(file, level)) < 0)
+	if ((result = file->open(file, level, repo)) < 0)
 		return result;
 
 	internal = git__malloc(sizeof(file_internal));
@@ -1147,20 +1149,20 @@ int git_config_open_default(git_config **out)
 
 	if (!git_config_find_global(&buf) || !git_config__global_location(&buf)) {
 		error = git_config_add_file_ondisk(cfg, buf.ptr,
-			GIT_CONFIG_LEVEL_GLOBAL, 0);
+			GIT_CONFIG_LEVEL_GLOBAL, NULL, 0);
 	}
 
 	if (!error && !git_config_find_xdg(&buf))
 		error = git_config_add_file_ondisk(cfg, buf.ptr,
-			GIT_CONFIG_LEVEL_XDG, 0);
+			GIT_CONFIG_LEVEL_XDG, NULL, 0);
 
 	if (!error && !git_config_find_system(&buf))
 		error = git_config_add_file_ondisk(cfg, buf.ptr,
-			GIT_CONFIG_LEVEL_SYSTEM, 0);
+			GIT_CONFIG_LEVEL_SYSTEM, NULL, 0);
 
 	if (!error && !git_config_find_programdata(&buf))
 		error = git_config_add_file_ondisk(cfg, buf.ptr,
-			GIT_CONFIG_LEVEL_PROGRAMDATA, 0);
+			GIT_CONFIG_LEVEL_PROGRAMDATA, NULL, 0);
 
 	git_buf_free(&buf);
 

data/vendor/libgit2/src/config.h

@@ -7,6 +7,8 @@
 #ifndef INCLUDE_config_h__
 #define INCLUDE_config_h__
 
+#include "common.h"
+
 #include "git2.h"
 #include "git2/config.h"
 #include "vector.h"

data/vendor/libgit2/src/config_cache.c

@@ -6,6 +6,7 @@
  */
 
 #include "common.h"
+
 #include "fileops.h"
 #include "repository.h"
 #include "config.h"

data/vendor/libgit2/src/config_file.c

@@ -5,7 +5,8 @@
  * a Linking Exception. For full terms see the included COPYING file.
  */
 
-#include "common.h"
+#include "config_file.h"
+
 #include "config.h"
 #include "filebuf.h"
 #include "sysdir.h"
@@ -16,6 +17,7 @@
 #include "git2/types.h"
 #include "strmap.h"
 #include "array.h"
+#include "config_parse.h"
 
 #include <ctype.h>
 #include <sys/types.h>
@@ -74,15 +76,6 @@ typedef struct git_config_file_iter {
 		 (iter) && (((tmp) = CVAR_LIST_NEXT(iter) || 1));\
 		 (iter) = (tmp))
 
-struct reader {
-	git_oid checksum;
-	char *file_path;
-	git_buf buffer;
-	char *read_ptr;
-	int line_number;
-	int eof;
-};
-
 typedef struct {
 	git_atomic refcount;
 	git_strmap *values;
@@ -93,20 +86,20 @@ typedef struct {
 	/* mutex to coordinate accessing the values */
 	git_mutex values_mutex;
 	refcounted_strmap *values;
+	const git_repository *repo;
+	git_config_level_t level;
 } diskfile_header;
 
 typedef struct {
 	diskfile_header header;
 
-	git_config_level_t level;
-
-	git_array_t(struct reader) readers;
+	git_array_t(git_config_parser) readers;
 
 	bool locked;
 	git_filebuf locked_buf;
 	git_buf locked_content;
 
-	char  *file_path;
+	struct config_file file;
 } diskfile_backend;
 
 typedef struct {
@@ -115,19 +108,13 @@ typedef struct {
 	diskfile_backend *snapshot_from;
 } diskfile_readonly_backend;
 
-static int config_read(git_strmap *values, diskfile_backend *cfg_file, struct reader *reader, git_config_level_t level, int depth);
-static int config_write(diskfile_backend *cfg, const char *key, const regex_t *preg, const char *value);
+static int config_read(git_strmap *values, const git_repository *repo, git_config_file *file, git_config_level_t level, int depth);
+static int config_write(diskfile_backend *cfg, const char *orig_key, const char *key, const regex_t *preg, const char *value);
 static char *escape_value(const char *ptr);
 
 int git_config_file__snapshot(git_config_backend **out, diskfile_backend *in);
 static int config_snapshot(git_config_backend **out, git_config_backend *in);
 
-static void set_parse_error(struct reader *reader, int col, const char *error_str)
-{
-	giterr_set(GITERR_CONFIG, "failed to parse config file: %s (in %s:%d, column %d)",
-		error_str, reader->file_path, reader->line_number, col);
-}
-
 static int config_error_readonly(void)
 {
 	giterr_set(GITERR_CONFIG, "this backend is read-only");
@@ -261,123 +248,131 @@ static int refcounted_strmap_alloc(refcounted_strmap **out)
 	return error;
 }
 
-static int config_open(git_config_backend *cfg, git_config_level_t level)
+static void config_file_clear(struct config_file *file)
+{
+	struct config_file *include;
+	uint32_t i;
+
+	if (file == NULL)
+		return;
+
+	git_array_foreach(file->includes, i, include) {
+		config_file_clear(include);
+	}
+	git_array_clear(file->includes);
+
+	git__free(file->path);
+}
+
+static int config_open(git_config_backend *cfg, git_config_level_t level, const git_repository *repo)
 {
 	int res;
-	struct reader *reader;
 	diskfile_backend *b = (diskfile_backend *)cfg;
 
-	b->level = level;
+	b->header.level = level;
+	b->header.repo = repo;
 
 	if ((res = refcounted_strmap_alloc(&b->header.values)) < 0)
 		return res;
 
-	git_array_init(b->readers);
-	reader = git_array_alloc(b->readers);
-	if (!reader) {
-		refcounted_strmap_free(b->header.values);
-		return -1;
-	}
-	memset(reader, 0, sizeof(struct reader));
-
-	reader->file_path = git__strdup(b->file_path);
-	GITERR_CHECK_ALLOC(reader->file_path);
-
-	git_buf_init(&reader->buffer, 0);
-	res = git_futils_readbuffer_updated(
-		&reader->buffer, b->file_path, &reader->checksum, NULL);
-
-	/* It's fine if the file doesn't exist */
-	if (res == GIT_ENOTFOUND)
+	if (!git_path_exists(b->file.path))
 		return 0;
 
-	if (res < 0 || (res = config_read(b->header.values->values, b, reader, level, 0)) < 0) {
+	if (res < 0 || (res = config_read(b->header.values->values, repo, &b->file, level, 0)) < 0) {
 		refcounted_strmap_free(b->header.values);
 		b->header.values = NULL;
 	}
 
-	reader = git_array_get(b->readers, 0);
-	git_buf_free(&reader->buffer);
-
 	return res;
 }
 
-/* The meat of the refresh, as we want to use it in different places */
-static int config__refresh(git_config_backend *cfg)
+static int config_is_modified(int *modified, struct config_file *file)
 {
-	refcounted_strmap *values = NULL, *tmp;
-	diskfile_backend *b = (diskfile_backend *)cfg;
-	struct reader *reader = NULL;
+	git_config_file *include;
+	git_buf buf = GIT_BUF_INIT;
+	git_oid hash;
+	uint32_t i;
 	int error = 0;
 
-	if ((error = refcounted_strmap_alloc(&values)) < 0)
-		goto out;
+	*modified = 0;
 
-	reader = git_array_get(b->readers, git_array_size(b->readers) - 1);
-	GITERR_CHECK_ALLOC(reader);
+	if ((error = git_futils_readbuffer(&buf, file->path)) < 0)
+		goto out;
 
-	if ((error = config_read(values->values, b, reader, b->level, 0)) < 0)
+	if ((error = git_hash_buf(&hash, buf.ptr, buf.size)) < 0)
 		goto out;
 
-	if ((error = git_mutex_lock(&b->header.values_mutex)) < 0) {
-		giterr_set(GITERR_OS, "failed to lock config backend");
+	if (!git_oid_equal(&hash, &file->checksum)) {
+		*modified = 1;
 		goto out;
 	}
 
-	tmp = b->header.values;
-	b->header.values = values;
-	values = tmp;
-
-	git_mutex_unlock(&b->header.values_mutex);
+	git_array_foreach(file->includes, i, include) {
+		if ((error = config_is_modified(modified, include)) < 0 || *modified)
+			goto out;
+	}
 
 out:
-	refcounted_strmap_free(values);
-	if (reader)
-		git_buf_free(&reader->buffer);
+	git_buf_free(&buf);
+
 	return error;
 }
 
 static int config_refresh(git_config_backend *cfg)
 {
-	int error = 0, updated = 0, any_updated = 0;
 	diskfile_backend *b = (diskfile_backend *)cfg;
-	struct reader *reader = NULL;
+	refcounted_strmap *values = NULL, *tmp;
+	git_config_file *include;
+	int error, modified;
 	uint32_t i;
 
-	for (i = 0; i < git_array_size(b->readers); i++) {
-		reader = git_array_get(b->readers, i);
-		error = git_futils_readbuffer_updated(
-			&reader->buffer, reader->file_path,
-			&reader->checksum, &updated);
+	if (b->header.parent.readonly)
+		return config_error_readonly();
+
+	error = config_is_modified(&modified, &b->file);
+	if (error < 0 && error != GIT_ENOTFOUND)
+		goto out;
+
+	if (!modified)
+		return 0;
 
-		if (error < 0 && error != GIT_ENOTFOUND)
-			return error;
+	if ((error = refcounted_strmap_alloc(&values)) < 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);
+
+	if ((error = config_read(values->values, b->header.repo, &b->file, b->header.level, 0)) < 0)
+		goto out;
 
-		if (updated)
-			any_updated = 1;
+	if ((error = git_mutex_lock(&b->header.values_mutex)) < 0) {
+		giterr_set(GITERR_OS, "failed to lock config backend");
+		goto out;
 	}
 
-	if (!any_updated)
-		return (error == GIT_ENOTFOUND) ? 0 : error;
+	tmp = b->header.values;
+	b->header.values = values;
+	values = tmp;
+
+	git_mutex_unlock(&b->header.values_mutex);
+
+out:
+	refcounted_strmap_free(values);
 
-	return config__refresh(cfg);
+	return (error == GIT_ENOTFOUND) ? 0 : error;
 }
 
 static void backend_free(git_config_backend *_backend)
 {
 	diskfile_backend *backend = (diskfile_backend *)_backend;
-	uint32_t i;
 
 	if (backend == NULL)
 		return;
 
-	for (i = 0; i < git_array_size(backend->readers); i++) {
-		struct reader *r = git_array_get(backend->readers, i);
-		git__free(r->file_path);
-	}
-	git_array_clear(backend->readers);
-
-	git__free(backend->file_path);
+	config_file_clear(&backend->file);
 	refcounted_strmap_free(backend->header.values);
 	git_mutex_free(&backend->header.values_mutex);
 	git__free(backend);
@@ -424,13 +419,13 @@ static int config_iterator_new(
 	diskfile_header *h;
 	git_config_file_iter *it;
 	git_config_backend *snapshot;
-	diskfile_backend *b = (diskfile_backend *) backend;
+	diskfile_header *bh = (diskfile_header *) backend;
 	int error;
 
 	if ((error = config_snapshot(&snapshot, backend)) < 0)
 		return error;
 
-	if ((error = snapshot->open(snapshot, b->level)) < 0)
+	if ((error = snapshot->open(snapshot, bh->level, bh->repo)) < 0)
 		return error;
 
 	it = git__calloc(1, sizeof(git_config_file_iter));
@@ -482,6 +477,12 @@ static int config_set(git_config_backend *cfg, const char *name, const char *val
 			goto out;
 		}
 
+		if (existing->included) {
+			giterr_set(GITERR_CONFIG, "modifying included variable is not supported");
+			ret = -1;
+			goto out;
+		}
+
 		/* don't update if old and new values already match */
 		if ((!existing->entry->value && !value) ||
 			(existing->entry->value && value &&
@@ -498,7 +499,7 @@ static int config_set(git_config_backend *cfg, const char *name, const char *val
 		GITERR_CHECK_ALLOC(esc_value);
 	}
 
-	if ((ret = config_write(b, key, NULL, esc_value)) < 0)
+	if ((ret = config_write(b, name, key, NULL, esc_value)) < 0)
 		goto out;
 
 	ret = config_refresh(cfg);
@@ -576,7 +577,7 @@ static int config_set_multivar(
 	}
 
 	/* If we do have it, set call config_write() and reload */
-	if ((result = config_write(b, key, &preg, value)) < 0)
+	if ((result = config_write(b, name, key, &preg, value)) < 0)
 		goto out;
 
 	result = config_refresh(cfg);
@@ -616,12 +617,17 @@ static int config_delete(git_config_backend *cfg, const char *name)
 	var = git_strmap_value_at(values, pos);
 	refcounted_strmap_free(map);
 
+	if (var->included) {
+		giterr_set(GITERR_CONFIG, "cannot delete included variable");
+		return -1;
+	}
+
 	if (var->next != NULL) {
 		giterr_set(GITERR_CONFIG, "cannot delete multivar with a single delete");
 		return -1;
 	}
 
-	if ((result = config_write(b, var->entry->name, NULL, NULL)) < 0)
+	if ((result = config_write(b, name, var->entry->name, NULL, NULL)) < 0)
 		return result;
 
 	return config_refresh(cfg);
@@ -662,7 +668,7 @@ static int config_delete_multivar(git_config_backend *cfg, const char *name, con
 		goto out;
 	}
 
-	if ((result = config_write(b, key, &preg, NULL)) < 0)
+	if ((result = config_write(b, name, key, &preg, NULL)) < 0)
 		goto out;
 
 	result = config_refresh(cfg);
@@ -685,10 +691,10 @@ static int config_lock(git_config_backend *_cfg)
 	diskfile_backend *cfg = (diskfile_backend *) _cfg;
 	int error;
 
-	if ((error = git_filebuf_open(&cfg->locked_buf, cfg->file_path, 0, GIT_CONFIG_FILE_MODE)) < 0)
+	if ((error = git_filebuf_open(&cfg->locked_buf, cfg->file.path, 0, GIT_CONFIG_FILE_MODE)) < 0)
 		return error;
 
-	error = git_futils_readbuffer(&cfg->locked_content, cfg->file_path);
+	error = git_futils_readbuffer(&cfg->locked_content, cfg->file.path);
 	if (error < 0 && error != GIT_ENOTFOUND) {
 		git_filebuf_cleanup(&cfg->locked_buf);
 		return error;
@@ -726,8 +732,9 @@ int git_config_file__ondisk(git_config_backend **out, const char *path)
 	backend->header.parent.version = GIT_CONFIG_BACKEND_VERSION;
 	git_mutex_init(&backend->header.values_mutex);
 
-	backend->file_path = git__strdup(path);
-	GITERR_CHECK_ALLOC(backend->file_path);
+	backend->file.path = git__strdup(path);
+	GITERR_CHECK_ALLOC(backend->file.path);
+	git_array_init(backend->file.includes);
 
 	backend->header.parent.open = config_open;
 	backend->header.parent.get = config_get;
@@ -810,7 +817,7 @@ static void backend_readonly_free(git_config_backend *_backend)
 	git__free(backend);
 }
 
-static int config_readonly_open(git_config_backend *cfg, git_config_level_t level)
+static int config_readonly_open(git_config_backend *cfg, git_config_level_t level, const git_repository *repo)
 {
 	diskfile_readonly_backend *b = (diskfile_readonly_backend *) cfg;
 	diskfile_backend *src = b->snapshot_from;
@@ -821,8 +828,9 @@ static int config_readonly_open(git_config_backend *cfg, git_config_level_t leve
 	if (!src_header->parent.readonly && (error = config_refresh(&src_header->parent)) < 0)
 		return error;
 
-	/* We're just copying data, don't care about the level */
+	/* We're just copying data, don't care about the level or repo*/
 	GIT_UNUSED(level);
+	GIT_UNUSED(repo);
 
 	if ((src_map = refcounted_strmap_take(src_header)) == NULL)
 		return -1;
@@ -861,397 +869,6 @@ int git_config_file__snapshot(git_config_backend **out, diskfile_backend *in)
 	return 0;
 }
 
-static int reader_getchar_raw(struct reader *reader)
-{
-	int c;
-
-	c = *reader->read_ptr++;
-
-	/*
-	Win 32 line breaks: if we find a \r\n sequence,
-	return only the \n as a newline
-	*/
-	if (c == '\r' && *reader->read_ptr == '\n') {
-		reader->read_ptr++;
-		c = '\n';
-	}
-
-	if (c == '\n')
-		reader->line_number++;
-
-	if (c == 0) {
-		reader->eof = 1;
-		c = '\0';
-	}
-
-	return c;
-}
-
-#define SKIP_WHITESPACE (1 << 1)
-#define SKIP_COMMENTS (1 << 2)
-
-static int reader_getchar(struct reader *reader, int flags)
-{
-	const int skip_whitespace = (flags & SKIP_WHITESPACE);
-	const int skip_comments = (flags & SKIP_COMMENTS);
-	int c;
-
-	assert(reader->read_ptr);
-
-	do {
-		c = reader_getchar_raw(reader);
-	} while (c != '\n' && c != '\0' && skip_whitespace && git__isspace(c));
-
-	if (skip_comments && (c == '#' || c == ';')) {
-		do {
-			c = reader_getchar_raw(reader);
-		} while (c != '\n' && c != '\0');
-	}
-
-	return c;
-}
-
-/*
- * Read the next char, but don't move the reading pointer.
- */
-static int reader_peek(struct reader *reader, int flags)
-{
-	void *old_read_ptr;
-	int old_lineno, old_eof;
-	int ret;
-
-	assert(reader->read_ptr);
-
-	old_read_ptr = reader->read_ptr;
-	old_lineno = reader->line_number;
-	old_eof = reader->eof;
-
-	ret = reader_getchar(reader, flags);
-
-	reader->read_ptr = old_read_ptr;
-	reader->line_number = old_lineno;
-	reader->eof = old_eof;
-
-	return ret;
-}
-
-/*
- * Read and consume a line, returning it in newly-allocated memory.
- */
-static char *reader_readline(struct reader *reader, bool skip_whitespace)
-{
-	char *line = NULL;
-	char *line_src, *line_end;
-	size_t line_len, alloc_len;
-
-	line_src = reader->read_ptr;
-
-	if (skip_whitespace) {
-		/* Skip empty empty lines */
-		while (git__isspace(*line_src))
-			++line_src;
-	}
-
-	line_end = strchr(line_src, '\n');
-
-	/* no newline at EOF */
-	if (line_end == NULL)
-		line_end = strchr(line_src, 0);
-
-	line_len = line_end - line_src;
-
-	if (GIT_ADD_SIZET_OVERFLOW(&alloc_len, line_len, 1) ||
-		(line = git__malloc(alloc_len)) == NULL) {
-		return NULL;
-	}
-
-	memcpy(line, line_src, line_len);
-
-	do line[line_len] = '\0';
-	while (line_len-- > 0 && git__isspace(line[line_len]));
-
-	if (*line_end == '\n')
-		line_end++;
-
-	if (*line_end == '\0')
-		reader->eof = 1;
-
-	reader->line_number++;
-	reader->read_ptr = line_end;
-
-	return line;
-}
-
-/*
- * Consume a line, without storing it anywhere
- */
-static void reader_consume_line(struct reader *reader)
-{
-	char *line_start, *line_end;
-
-	line_start = reader->read_ptr;
-	line_end = strchr(line_start, '\n');
-	/* No newline at EOF */
-	if(line_end == NULL){
-		line_end = strchr(line_start, '\0');
-	}
-
-	if (*line_end == '\n')
-		line_end++;
-
-	if (*line_end == '\0')
-		reader->eof = 1;
-
-	reader->line_number++;
-	reader->read_ptr = line_end;
-}
-
-GIT_INLINE(int) config_keychar(int c)
-{
-	return isalnum(c) || c == '-';
-}
-
-static int parse_section_header_ext(struct reader *reader, const char *line, const char *base_name, char **section_name)
-{
-	int c, rpos;
-	char *first_quote, *last_quote;
-	git_buf buf = GIT_BUF_INIT;
-	size_t quoted_len, alloc_len, base_name_len = strlen(base_name);
-
-	/*
-	 * 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.
-	 */
-
-	first_quote = strchr(line, '"');
-	if (first_quote == NULL) {
-		set_parse_error(reader, 0, "Missing quotation marks in section header");
-		goto end_error;
-	}
-
-	last_quote = strrchr(line, '"');
-	quoted_len = last_quote - first_quote;
-
-	if (quoted_len == 0) {
-		set_parse_error(reader, 0, "Missing closing quotation mark in section header");
-		goto end_error;
-	}
-
-	GITERR_CHECK_ALLOC_ADD(&alloc_len, base_name_len, quoted_len);
-	GITERR_CHECK_ALLOC_ADD(&alloc_len, alloc_len, 2);
-
-	if (git_buf_grow(&buf, alloc_len) < 0 ||
-	    git_buf_printf(&buf, "%s.", base_name) < 0)
-		goto end_error;
-
-	rpos = 0;
-
-	line = first_quote;
-	c = line[++rpos];
-
-	/*
-	 * 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 {
-
-		switch (c) {
-		case 0:
-			set_parse_error(reader, 0, "Unexpected end-of-line in section header");
-			goto end_error;
-
-		case '"':
-			goto end_parse;
-
-		case '\\':
-			c = line[++rpos];
-
-			if (c == 0) {
-				set_parse_error(reader, rpos, "Unexpected end-of-line in section header");
-				goto end_error;
-			}
-
-		default:
-			break;
-		}
-
-		git_buf_putc(&buf, (char)c);
-		c = line[++rpos];
-	} while (line + rpos < last_quote);
-
-end_parse:
-	if (git_buf_oom(&buf))
-		goto end_error;
-
-	if (line[rpos] != '"' || line[rpos + 1] != ']') {
-		set_parse_error(reader, rpos, "Unexpected text after closing quotes");
-		git_buf_free(&buf);
-		return -1;
-	}
-
-	*section_name = git_buf_detach(&buf);
-	return 0;
-
-end_error:
-	git_buf_free(&buf);
-
-	return -1;
-}
-
-static int parse_section_header(struct reader *reader, char **section_out)
-{
-	char *name, *name_end;
-	int name_length, c, pos;
-	int result;
-	char *line;
-	size_t line_len;
-
-	line = reader_readline(reader, true);
-	if (line == NULL)
-		return -1;
-
-	/* find the end of the variable's name */
-	name_end = strrchr(line, ']');
-	if (name_end == NULL) {
-		git__free(line);
-		set_parse_error(reader, 0, "Missing ']' in section header");
-		return -1;
-	}
-
-	GITERR_CHECK_ALLOC_ADD(&line_len, (size_t)(name_end - line), 1);
-	name = git__malloc(line_len);
-	GITERR_CHECK_ALLOC(name);
-
-	name_length = 0;
-	pos = 0;
-
-	/* Make sure we were given a section header */
-	c = line[pos++];
-	assert(c == '[');
-
-	c = line[pos++];
-
-	do {
-		if (git__isspace(c)){
-			name[name_length] = '\0';
-			result = parse_section_header_ext(reader, line, name, section_out);
-			git__free(line);
-			git__free(name);
-			return result;
-		}
-
-		if (!config_keychar(c) && c != '.') {
-			set_parse_error(reader, pos, "Unexpected character in header");
-			goto fail_parse;
-		}
-
-		name[name_length++] = (char)git__tolower(c);
-
-	} while ((c = line[pos++]) != ']');
-
-	if (line[pos - 1] != ']') {
-		set_parse_error(reader, pos, "Unexpected end of file");
-		goto fail_parse;
-	}
-
-	git__free(line);
-
-	name[name_length] = 0;
-	*section_out = name;
-
-	return 0;
-
-fail_parse:
-	git__free(line);
-	git__free(name);
-	return -1;
-}
-
-static int skip_bom(struct reader *reader)
-{
-	git_bom_t bom;
-	int bom_offset = git_buf_text_detect_bom(&bom,
-		&reader->buffer, reader->read_ptr - reader->buffer.ptr);
-
-	if (bom == GIT_BOM_UTF8)
-		reader->read_ptr += bom_offset;
-
-	/* TODO: reference implementation is pretty stupid with BoM */
-
-	return 0;
-}
-
-/*
-	(* basic types *)
-	digit = "0".."9"
-	integer = digit { digit }
-	alphabet = "a".."z" + "A" .. "Z"
-
-	section_char = alphabet | "." | "-"
-	extension_char = (* any character except newline *)
-	any_char = (* any character *)
-	variable_char = "alphabet" | "-"
-
-
-	(* actual grammar *)
-	config = { section }
-
-	section = header { definition }
-
-	header = "[" section [subsection | subsection_ext] "]"
-
-	subsection = "." section
-	subsection_ext = "\"" extension "\""
-
-	section = section_char { section_char }
-	extension = extension_char { extension_char }
-
-	definition = variable_name ["=" variable_value] "\n"
-
-	variable_name = variable_char { variable_char }
-	variable_value = string | boolean | integer
-
-	string = quoted_string | plain_string
-	quoted_string = "\"" plain_string "\""
-	plain_string = { any_char }
-
-	boolean = boolean_true | boolean_false
-	boolean_true = "yes" | "1" | "true" | "on"
-	boolean_false = "no" | "0" | "false" | "off"
-*/
-
-static int strip_comments(char *line, int in_quotes)
-{
-	int quote_count = in_quotes, backslash_count = 0;
-	char *ptr;
-
-	for (ptr = line; *ptr; ++ptr) {
-		if (ptr[0] == '"' && ptr > line && ptr[-1] != '\\')
-			quote_count++;
-
-		if ((ptr[0] == ';' || ptr[0] == '#') &&
-			(quote_count % 2) == 0 &&
-			(backslash_count % 2) == 0) {
-			ptr[0] = '\0';
-			break;
-		}
-
-		if (ptr[0] == '\\')
-			backslash_count++;
-		else
-			backslash_count = 0;
-	}
-
-	/* skip any space at the end */
-	while (ptr > line && git__isspace(ptr[-1])) {
-		ptr--;
-	}
-	ptr[0] = '\0';
-
-	return quote_count;
-}
-
 static int included_path(git_buf *out, const char *dir, const char *path)
 {
 	/* From the user's home */
@@ -1261,9 +878,6 @@ static int included_path(git_buf *out, const char *dir, const char *path)
 	return git_path_join_unrooted(out, path, dir, NULL);
 }
 
-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)
 {
@@ -1281,9 +895,9 @@ static char *escape_value(const char *ptr)
 		return NULL;
 
 	while (*ptr != '\0') {
-		if ((esc = strchr(escaped, *ptr)) != NULL) {
+		if ((esc = strchr(git_config_escaped, *ptr)) != NULL) {
 			git_buf_putc(&buf, '\\');
-			git_buf_putc(&buf, escapes[esc - escaped]);
+			git_buf_putc(&buf, git_config_escapes[esc - git_config_escaped]);
 		} else {
 			git_buf_putc(&buf, *ptr);
 		}
@@ -1298,266 +912,151 @@ static char *escape_value(const char *ptr)
 	return git_buf_detach(&buf);
 }
 
-/* '\"' -> '"' etc */
-static int unescape_line(
-	char **out, bool *is_multi, const char *ptr, int quote_count)
-{
-	char *str, *fixed, *esc;
-	size_t ptr_len = strlen(ptr), alloc_len;
-
-	*is_multi = false;
-
-	if (GIT_ADD_SIZET_OVERFLOW(&alloc_len, ptr_len, 1) ||
-		(str = git__malloc(alloc_len)) == NULL) {
-		return -1;
-	}
-
-	fixed = str;
-
-	while (*ptr != '\0') {
-		if (*ptr == '"') {
-			quote_count++;
-		} else if (*ptr != '\\') {
-			*fixed++ = *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') {
-				*is_multi = true;
-				goto done;
-			}
-			if ((esc = strchr(escapes, *ptr)) != NULL) {
-				*fixed++ = escaped[esc - escapes];
-			} else {
-				git__free(str);
-				giterr_set(GITERR_CONFIG, "invalid escape at %s", ptr);
-				return -1;
-			}
-		}
-		ptr++;
-	}
-
-done:
-	*fixed = '\0';
-	*out = str;
-
-	return 0;
-}
+struct parse_data {
+	const git_repository *repo;
+	const char *file_path;
+	git_strmap *values;
+	git_config_level_t level;
+	int depth;
+};
 
-static int parse_multiline_variable(struct reader *reader, git_buf *value, int in_quotes)
+static int parse_include(git_config_parser *reader,
+	struct parse_data *parse_data, const char *file)
 {
-	int quote_count;
-	bool multiline = true;
-
-	while (multiline) {
-		char *line = NULL, *proc_line = NULL;
-		int error;
-
-		/* Check that the next line exists */
-		line = reader_readline(reader, false);
-		GITERR_CHECK_ALLOC(line);
-
-		/*
-		 * We've reached the end of the file, there is no continuation.
-		 * (this is not an error).
-		 */
-		if (line[0] == '\0') {
-			error = 0;
-			goto out;
-		}
+	struct config_file *include;
+	git_buf path = GIT_BUF_INIT;
+	char *dir;
+	int result;
 
-		/* If it was just a comment, pretend it didn't exist */
-		quote_count = strip_comments(line, !!in_quotes);
-		if (line[0] == '\0')
-			goto next;
+	if ((result = git_path_dirname_r(&path, reader->file->path)) < 0)
+		return result;
 
-		if ((error = unescape_line(&proc_line, &multiline,
-					   line, in_quotes)) < 0)
-			goto out;
+	dir = git_buf_detach(&path);
+	result = included_path(&path, dir, file);
+	git__free(dir);
 
-		/* Add this line to the multiline var */
-		if ((error = git_buf_puts(value, proc_line)) < 0)
-			goto out;
+	if (result < 0)
+		return result;
 
-next:
-		git__free(line);
-		git__free(proc_line);
-		in_quotes = quote_count;
-		continue;
+	include = git_array_alloc(reader->file->includes);
+	memset(include, 0, sizeof(*include));
+	git_array_init(include->includes);
+	include->path = git_buf_detach(&path);
 
-out:
-		git__free(line);
-		git__free(proc_line);
-		return error;
-	}
+	result = config_read(parse_data->values, parse_data->repo,
+		include, parse_data->level, parse_data->depth+1);
 
-	return 0;
-}
+	if (result == GIT_ENOTFOUND) {
+		giterr_clear();
+		result = 0;
+	}
 
-GIT_INLINE(bool) is_namechar(char c)
-{
-	return isalnum(c) || c == '-';
+	return result;
 }
 
-static int parse_name(
-	char **name, const char **value, struct reader *reader, const char *line)
+static int do_match_gitdir(
+	int *matches,
+	const git_repository *repo,
+	const char *cfg_file,
+	const char *value,
+	bool case_insensitive)
 {
-	const char *name_end = line, *value_start;
+	git_buf path = GIT_BUF_INIT;
+	int error, fnmatch_flags;
 
-	*name = NULL;
-	*value = NULL;
-
-	while (*name_end && is_namechar(*name_end))
-		name_end++;
+	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 == name_end) {
-		set_parse_error(reader, 0, "Invalid configuration key");
-		return -1;
+	if (git_buf_oom(&path)) {
+		error = -1;
+		goto out;
 	}
 
-	value_start = name_end;
+	if (git_path_is_dirsep(value[strlen(value) - 1]))
+		git_buf_puts(&path, "**");
 
-	while (*value_start && git__isspace(*value_start))
-		value_start++;
+	fnmatch_flags = FNM_PATHNAME|FNM_LEADING_DIR;
+	if (case_insensitive)
+		fnmatch_flags |= FNM_IGNORECASE;
 
-	if (*value_start == '=') {
-		*value = value_start + 1;
-	} else if (*value_start) {
-		set_parse_error(reader, 0, "Invalid configuration key");
-		return -1;
-	}
+	if ((error = p_fnmatch(path.ptr, git_repository_path(repo), fnmatch_flags)) < 0)
+		goto out;
 
-	if ((*name = git__strndup(line, name_end - line)) == NULL)
-		return -1;
+	*matches = (error == 0);
 
-	return 0;
+out:
+	git_buf_free(&path);
+	return error;
 }
 
-static int parse_variable(struct reader *reader, char **var_name, char **var_value)
+static int conditional_match_gitdir(
+	int *matches,
+	const git_repository *repo,
+	const char *cfg_file,
+	const char *value)
 {
-	const char *value_start = NULL;
-	char *line;
-	int quote_count;
-	bool multiline;
-
-	line = reader_readline(reader, true);
-	if (line == NULL)
-		return -1;
-
-	quote_count = strip_comments(line, 0);
-
-	/* If there is no value, boolean true is assumed */
-	*var_value = NULL;
-
-	if (parse_name(var_name, &value_start, reader, line) < 0)
-		goto on_error;
-
-	/*
-	 * Now, let's try to parse the value
-	 */
-	if (value_start != NULL) {
-		while (git__isspace(value_start[0]))
-			value_start++;
-
-		if (unescape_line(var_value, &multiline, value_start, 0) < 0)
-			goto on_error;
-
-		if (multiline) {
-			git_buf multi_value = GIT_BUF_INIT;
-			git_buf_attach(&multi_value, *var_value, 0);
-
-			if (parse_multiline_variable(reader, &multi_value, quote_count) < 0 ||
-				git_buf_oom(&multi_value)) {
-				git_buf_free(&multi_value);
-				goto on_error;
-			}
-
-			*var_value = git_buf_detach(&multi_value);
-		}
-	}
-
-	git__free(line);
-	return 0;
-
-on_error:
-	git__free(*var_name);
-	git__free(line);
-	return -1;
+	return do_match_gitdir(matches, repo, cfg_file, value, false);
 }
 
-static int config_parse(
-	struct reader *reader,
-	int (*on_section)(struct reader **reader, const char *current_section, const char *line, size_t line_len, void *data),
-	int (*on_variable)(struct reader **reader, const char *current_section, char *var_name, char *var_value, const char *line, size_t line_len, void *data),
-	int (*on_comment)(struct reader **reader, const char *line, size_t line_len, void *data),
-	int (*on_eof)(struct reader **reader, const char *current_section, void *data),
-	void *data)
+static int conditional_match_gitdir_i(
+	int *matches,
+	const git_repository *repo,
+	const char *cfg_file,
+	const char *value)
 {
-	char *current_section = NULL, *var_name, *var_value, *line_start;
-	char c;
-	size_t line_len;
-	int result = 0;
+	return do_match_gitdir(matches, repo, cfg_file, value, true);
+}
 
-	skip_bom(reader);
+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 }
+};
 
-	while (result == 0 && !reader->eof) {
-		line_start = reader->read_ptr;
+static int parse_conditional_include(git_config_parser *reader,
+	struct parse_data *parse_data, const char *section, const char *file)
+{
+	char *condition;
+	size_t i;
+	int error = 0, matches;
 
-		c = reader_peek(reader, SKIP_WHITESPACE);
+	if (!parse_data->repo)
+		return 0;
 
-		switch (c) {
-		case '\0': /* EOF when peeking, set EOF in the reader to exit the loop */
-			reader->eof = 1;
-			break;
+	condition = git__substrdup(section + strlen("includeIf."),
+				   strlen(section) - strlen("includeIf.") - strlen(".path"));
 
-		case '[': /* section header, new section begins */
-			git__free(current_section);
-			current_section = NULL;
+	for (i = 0; i < ARRAY_SIZE(conditions); i++) {
+		if (git__prefixcmp(condition, conditions[i].prefix))
+			continue;
 
-			if ((result = parse_section_header(reader, &current_section)) == 0 && on_section) {
-				line_len = reader->read_ptr - line_start;
-				result = on_section(&reader, current_section, line_start, line_len, data);
-			}
+		if ((error = conditions[i].matches(&matches,
+						   parse_data->repo,
+						   parse_data->file_path,
+						   condition + strlen(conditions[i].prefix))) < 0)
 			break;
 
-		case '\n': /* comment or whitespace-only */
-		case ';':
-		case '#':
-			reader_consume_line(reader);
+		if (matches)
+			error = parse_include(reader, parse_data, file);
 
-			if (on_comment) {
-				line_len = reader->read_ptr - line_start;
-				result = on_comment(&reader, line_start, line_len, data);
-			}
-			break;
-
-		default: /* assume variable declaration */
-			if ((result = parse_variable(reader, &var_name, &var_value)) == 0 && on_variable) {
-				line_len = reader->read_ptr - line_start;
-				result = on_variable(&reader, current_section, var_name, var_value, line_start, line_len, data);
-			}
-			break;
-		}
+		break;
 	}
 
-	if (on_eof)
-		result = on_eof(&reader, current_section, data);
-
-	git__free(current_section);
-	return result;
+	git__free(condition);
+	return error;
 }
 
-struct parse_data {
-	git_strmap *values;
-	diskfile_backend *cfg_file;
-	uint32_t reader_idx;
-	git_config_level_t level;
-	int depth;
-};
-
 static int read_on_variable(
-	struct reader **reader,
+	git_config_parser *reader,
 	const char *current_section,
 	char *var_name,
 	char *var_value,
@@ -1598,74 +1097,61 @@ static int read_on_variable(
 	result = 0;
 
 	/* Add or append the new config option */
-	if (!git__strcmp(var->entry->name, "include.path") && var->entry->value) {
-		struct reader *r;
-		git_buf path = GIT_BUF_INIT;
-		char *dir;
-		uint32_t index;
-
-		r = git_array_alloc(parse_data->cfg_file->readers);
-		/* The reader may have been reallocated */
-		*reader = git_array_get(parse_data->cfg_file->readers, parse_data->reader_idx);
-		memset(r, 0, sizeof(struct reader));
-
-		if ((result = git_path_dirname_r(&path, (*reader)->file_path)) < 0)
-			return result;
+	if (!git__strcmp(var->entry->name, "include.path"))
+		result = parse_include(reader, parse_data, var->entry->value);
+	else if (!git__prefixcmp(var->entry->name, "includeif.") &&
+	         !git__suffixcmp(var->entry->name, ".path"))
+		result = parse_conditional_include(reader, parse_data,
+						   var->entry->name, var->entry->value);
 
-		/* We need to know our index in the array, as the next config_parse call may realloc */
-		index = git_array_size(parse_data->cfg_file->readers) - 1;
-		dir = git_buf_detach(&path);
-		result = included_path(&path, dir, var->entry->value);
-		git__free(dir);
-
-		if (result < 0)
-			return result;
-
-		r->file_path = git_buf_detach(&path);
-		git_buf_init(&r->buffer, 0);
-
-		result = git_futils_readbuffer_updated(
-			&r->buffer, r->file_path, &r->checksum, NULL);
-
-		if (result == 0) {
-			result = config_read(parse_data->values, parse_data->cfg_file, r, parse_data->level, parse_data->depth+1);
-			r = git_array_get(parse_data->cfg_file->readers, index);
-			*reader = git_array_get(parse_data->cfg_file->readers, parse_data->reader_idx);
-		} else if (result == GIT_ENOTFOUND) {
-			giterr_clear();
-			result = 0;
-		}
-
-		git_buf_free(&r->buffer);
-	}
 
 	return result;
 }
 
-static int config_read(git_strmap *values, diskfile_backend *cfg_file, struct reader *reader, git_config_level_t level, int depth)
+static int config_read(
+	git_strmap *values,
+	const git_repository *repo,
+	git_config_file *file,
+	git_config_level_t level,
+	int depth)
 {
 	struct parse_data parse_data;
+	git_config_parser reader;
+	git_buf contents = GIT_BUF_INIT;
+	int error;
 
 	if (depth >= MAX_INCLUDE_DEPTH) {
 		giterr_set(GITERR_CONFIG, "maximum config include depth reached");
 		return -1;
 	}
 
+	if ((error = git_futils_readbuffer(&contents, file->path)) < 0)
+		goto out;
+
+	git_parse_ctx_init(&reader.ctx, contents.ptr, contents.size);
+
+	if ((error = git_hash_buf(&file->checksum, contents.ptr, contents.size)) < 0)
+		goto out;
+
 	/* Initialize the reading position */
-	reader->read_ptr = reader->buffer.ptr;
-	reader->eof = 0;
+	reader.file = file;
+	git_parse_ctx_init(&reader.ctx, contents.ptr, contents.size);
 
 	/* If the file is empty, there's nothing for us to do */
-	if (*reader->read_ptr == '\0')
-		return 0;
+	if (!reader.ctx.content || *reader.ctx.content == '\0')
+		goto out;
 
+	parse_data.repo = repo;
+	parse_data.file_path = file->path;
 	parse_data.values = values;
-	parse_data.cfg_file = cfg_file;
-	parse_data.reader_idx = git_array_size(cfg_file->readers) - 1;
 	parse_data.level = level;
 	parse_data.depth = depth;
 
-	return config_parse(reader, NULL, read_on_variable, NULL, NULL, &parse_data);
+	error = git_config_parse(&reader, NULL, read_on_variable, NULL, NULL, &parse_data);
+
+out:
+	git_buf_free(&contents);
+	return error;
 }
 
 static int write_section(git_buf *fbuf, const char *key)
@@ -1721,7 +1207,9 @@ struct write_data {
 	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;
@@ -1749,7 +1237,7 @@ static int write_value(struct write_data *write_data)
 
 	q = quotes_for_value(write_data->value);
 	result = git_buf_printf(write_data->buf,
-		"\t%s = %s%s%s\n", write_data->name, q, write_data->value, q);
+		"\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`
 	 * to `NULL` will prevent us from trying to write it again later (in
@@ -1762,7 +1250,7 @@ static int write_value(struct write_data *write_data)
 }
 
 static int write_on_section(
-	struct reader **reader,
+	git_config_parser *reader,
 	const char *current_section,
 	const char *line,
 	size_t line_len,
@@ -1798,7 +1286,7 @@ static int write_on_section(
 }
 
 static int write_on_variable(
-	struct reader **reader,
+	git_config_parser *reader,
 	const char *current_section,
 	char *var_name,
 	char *var_value,
@@ -1848,7 +1336,7 @@ static int write_on_variable(
 	return write_value(write_data);
 }
 
-static int write_on_comment(struct reader **reader, const char *line, size_t line_len, void *data)
+static int write_on_comment(git_config_parser *reader, const char *line, size_t line_len, void *data)
 {
 	struct write_data *write_data;
 
@@ -1859,7 +1347,7 @@ static int write_on_comment(struct reader **reader, const char *line, size_t lin
 }
 
 static int write_on_eof(
-	struct reader **reader, const char *current_section, void *data)
+	git_config_parser *reader, const char *current_section, void *data)
 {
 	struct write_data *write_data = (struct write_data *)data;
 	int result = 0;
@@ -1880,7 +1368,7 @@ static int write_on_eof(
 	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->section);
+			result = write_section(write_data->buf, write_data->orig_section);
 
 		if (!result)
 			result = write_value(write_data);
@@ -1892,37 +1380,35 @@ static int write_on_eof(
 /*
  * 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 int config_write(diskfile_backend *cfg, const char *orig_key, const char *key, const regex_t *preg, const char* value)
 {
 	int result;
-	char *section, *name, *ldot;
+	char *orig_section, *section, *orig_name, *name, *ldot;
 	git_filebuf file = GIT_FILEBUF_INIT;
-	git_buf buf = GIT_BUF_INIT;
-	struct reader *reader = git_array_get(cfg->readers, 0);
+	git_buf buf = GIT_BUF_INIT, contents = GIT_BUF_INIT;
+	git_config_parser reader;
 	struct write_data write_data;
 
+	memset(&reader, 0, sizeof(reader));
+	reader.file = &cfg->file;
+
 	if (cfg->locked) {
-		result = git_buf_puts(&reader->buffer, git_buf_cstr(&cfg->locked_content));
+		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_free(&reader->buffer);
+			     &file, cfg->file.path, GIT_FILEBUF_HASH_CONTENTS, GIT_CONFIG_FILE_MODE)) < 0) {
+			git_buf_free(&contents);
 			return result;
 		}
 
 		/* We need to read in our own config file */
-		result = git_futils_readbuffer(&reader->buffer, cfg->file_path);
+		result = git_futils_readbuffer(&contents, cfg->file.path);
 	}
 
 	/* Initialise the reading position */
-	if (result == GIT_ENOTFOUND) {
-		reader->read_ptr = NULL;
-		reader->eof = 1;
-		git_buf_clear(&reader->buffer);
-	} else if (result == 0) {
-		reader->read_ptr = reader->buffer.ptr;
-		reader->eof = 0;
+	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 */
@@ -1931,18 +1417,32 @@ static int config_write(diskfile_backend *cfg, const char *key, const regex_t *p
 	ldot = strrchr(key, '.');
 	name = ldot + 1;
 	section = git__strndup(key, ldot - key);
+	GITERR_CHECK_ALLOC(section);
+
+	ldot = strrchr(orig_key, '.');
+	orig_name = ldot + 1;
+	orig_section = git__strndup(orig_key, ldot - orig_key);
+	GITERR_CHECK_ALLOC(orig_section);
 
 	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 = config_parse(reader, write_on_section, write_on_variable, write_on_comment, write_on_eof, &write_data);
+	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_free(&write_data.buffered_comment);
 
 	if (result < 0) {
@@ -1962,6 +1462,7 @@ static int config_write(diskfile_backend *cfg, const char *key, const regex_t *p
 
 done:
 	git_buf_free(&buf);
-	git_buf_free(&reader->buffer);
+	git_buf_free(&contents);
+	git_parse_ctx_clear(&reader.ctx);
 	return result;
 }