rugged 0.27.10.1 → 0.28.0

data/vendor/libgit2/src/commit.h

@@ -35,5 +35,6 @@ struct git_commit {
 
 void git_commit__free(void *commit);
 int git_commit__parse(void *commit, git_odb_object *obj);
+int git_commit__parse_raw(void *commit, const char *data, size_t size);
 
 #endif

data/vendor/libgit2/src/commit_list.c

@@ -61,7 +61,7 @@ static int commit_error(git_commit_list_node *commit, const char *msg)
 	git_oid_fmt(commit_oid, &commit->oid);
 	commit_oid[GIT_OID_HEXSZ] = '\0';
 
-	giterr_set(GITERR_ODB, "failed to parse commit %s - %s", commit_oid, msg);
+	git_error_set(GIT_ERROR_ODB, "failed to parse commit %s - %s", commit_oid, msg);
 
 	return -1;
 }
@@ -69,15 +69,11 @@ static int commit_error(git_commit_list_node *commit, const char *msg)
 static git_commit_list_node **alloc_parents(
 	git_revwalk *walk, git_commit_list_node *commit, size_t n_parents)
 {
-	size_t bytes;
-
 	if (n_parents <= PARENTS_PER_COMMIT)
 		return (git_commit_list_node **)((char *)commit + sizeof(git_commit_list_node));
 
-	if (git__multiply_sizet_overflow(&bytes, n_parents, sizeof(git_commit_list_node *)))
-		return NULL;
-
-	return (git_commit_list_node **)git_pool_malloc(&walk->commit_pool, bytes);
+	return (git_commit_list_node **)git_pool_malloc(
+		&walk->commit_pool, (uint32_t)(n_parents * sizeof(git_commit_list_node *)));
 }
 
 
@@ -130,7 +126,7 @@ static int commit_quick_parse(
 	}
 
 	commit->parents = alloc_parents(walk, commit, parents);
-	GITERR_CHECK_ALLOC(commit->parents);
+	GIT_ERROR_CHECK_ALLOC(commit->parents);
 
 	buffer = parents_start;
 	for (i = 0; i < parents; ++i) {
@@ -196,8 +192,8 @@ int git_commit_list_parse(git_revwalk *walk, git_commit_list_node *commit)
 	if ((error = git_odb_read(&obj, walk->odb, &commit->oid)) < 0)
 		return error;
 
-	if (obj->cached.type != GIT_OBJ_COMMIT) {
-		giterr_set(GITERR_INVALID, "object is no commit object");
+	if (obj->cached.type != GIT_OBJECT_COMMIT) {
+		git_error_set(GIT_ERROR_INVALID, "object is no commit object");
 		error = -1;
 	} else
 		error = commit_quick_parse(

data/vendor/libgit2/src/common.h

@@ -17,8 +17,10 @@
 /** Declare a function as always inlined. */
 #if defined(_MSC_VER)
 # define GIT_INLINE(type) static __inline type
+#elif defined(__GNUC__)
+# define GIT_INLINE(type) static __inline__ type
 #else
-# define GIT_INLINE(type) static inline type
+# define GIT_INLINE(type) static type
 #endif
 
 /** Support for gcc/clang __has_builtin intrinsic */
@@ -87,30 +89,30 @@
 /**
  * Check a pointer allocation result, returning -1 if it failed.
  */
-#define GITERR_CHECK_ALLOC(ptr) if (ptr == NULL) { return -1; }
+#define GIT_ERROR_CHECK_ALLOC(ptr) if (ptr == NULL) { return -1; }
 
 /**
  * Check a buffer allocation result, returning -1 if it failed.
  */
-#define GITERR_CHECK_ALLOC_BUF(buf) if ((void *)(buf) == NULL || git_buf_oom(buf)) { return -1; }
+#define GIT_ERROR_CHECK_ALLOC_BUF(buf) if ((void *)(buf) == NULL || git_buf_oom(buf)) { return -1; }
 
 /**
  * Check a return value and propagate result if non-zero.
  */
-#define GITERR_CHECK_ERROR(code) \
+#define GIT_ERROR_CHECK_ERROR(code) \
 	do { int _err = (code); if (_err) return _err; } while (0)
 
 /**
  * Set the error message for this thread, formatting as needed.
  */
 
-void giterr_set(int error_class, const char *string, ...) GIT_FORMAT_PRINTF(2, 3);
+void git_error_set(int error_class, const char *string, ...) GIT_FORMAT_PRINTF(2, 3);
 
 /**
  * Set the error message for a regex failure, using the internal regex
  * error code lookup and return a libgit error code.
  */
-int giterr_set_regex(const regex_t *regex, int error_code);
+int git_error_set_regex(const regex_t *regex, int error_code);
 
 /**
  * Set error message for user callback if needed.
@@ -120,35 +122,35 @@ int giterr_set_regex(const regex_t *regex, int error_code);
  *
  * @return This always returns the `error_code` parameter.
  */
-GIT_INLINE(int) giterr_set_after_callback_function(
+GIT_INLINE(int) git_error_set_after_callback_function(
 	int error_code, const char *action)
 {
 	if (error_code) {
-		const git_error *e = giterr_last();
+		const git_error *e = git_error_last();
 		if (!e || !e->message)
-			giterr_set(e ? e->klass : GITERR_CALLBACK,
+			git_error_set(e ? e->klass : GIT_ERROR_CALLBACK,
 				"%s callback returned %d", action, error_code);
 	}
 	return error_code;
 }
 
 #ifdef GIT_WIN32
-#define giterr_set_after_callback(code) \
-	giterr_set_after_callback_function((code), __FUNCTION__)
+#define git_error_set_after_callback(code) \
+	git_error_set_after_callback_function((code), __FUNCTION__)
 #else
-#define giterr_set_after_callback(code) \
-	giterr_set_after_callback_function((code), __func__)
+#define git_error_set_after_callback(code) \
+	git_error_set_after_callback_function((code), __func__)
 #endif
 
 /**
  * Gets the system error code for this thread.
  */
-int giterr_system_last(void);
+int git_error_system_last(void);
 
 /**
  * Sets the system error code for this thread.
  */
-void giterr_system_set(int code);
+void git_error_system_set(int code);
 
 /**
  * Structure to preserve libgit2 error state
@@ -164,20 +166,20 @@ typedef struct {
  * If `error_code` is zero, this does not clear the current error state.
  * You must either restore this error state, or free it.
  */
-extern int giterr_state_capture(git_error_state *state, int error_code);
+extern int git_error_state_capture(git_error_state *state, int error_code);
 
 /**
  * Restore error state to a previous value, returning saved error code.
  */
-extern int giterr_state_restore(git_error_state *state);
+extern int git_error_state_restore(git_error_state *state);
 
 /** Free an error state. */
-extern void giterr_state_free(git_error_state *state);
+extern void git_error_state_free(git_error_state *state);
 
 /**
  * Check a versioned structure for validity
  */
-GIT_INLINE(int) giterr__check_version(const void *structure, unsigned int expected_max, const char *name)
+GIT_INLINE(int) git_error__check_version(const void *structure, unsigned int expected_max, const char *name)
 {
 	unsigned int actual;
 
@@ -188,10 +190,10 @@ GIT_INLINE(int) giterr__check_version(const void *structure, unsigned int expect
 	if (actual > 0 && actual <= expected_max)
 		return 0;
 
-	giterr_set(GITERR_INVALID, "invalid version %d on %s", actual, name);
+	git_error_set(GIT_ERROR_INVALID, "invalid version %d on %s", actual, name);
 	return -1;
 }
-#define GITERR_CHECK_VERSION(S,V,N) if (giterr__check_version(S,V,N) < 0) return -1
+#define GIT_ERROR_CHECK_VERSION(S,V,N) if (git_error__check_version(S,V,N) < 0) return -1
 
 /**
  * Initialize a structure with a version.
@@ -205,42 +207,42 @@ GIT_INLINE(void) git__init_structure(void *structure, size_t len, unsigned int v
 
 #define GIT_INIT_STRUCTURE_FROM_TEMPLATE(PTR,VERSION,TYPE,TPL) do { \
 	TYPE _tmpl = TPL; \
-	GITERR_CHECK_VERSION(&(VERSION), _tmpl.version, #TYPE);	\
+	GIT_ERROR_CHECK_VERSION(&(VERSION), _tmpl.version, #TYPE);	\
 	memcpy((PTR), &_tmpl, sizeof(_tmpl)); } while (0)
 
 
 /** Check for additive overflow, setting an error if would occur. */
 #define GIT_ADD_SIZET_OVERFLOW(out, one, two) \
-	(git__add_sizet_overflow(out, one, two) ? (giterr_set_oom(), 1) : 0)
+	(git__add_sizet_overflow(out, one, two) ? (git_error_set_oom(), 1) : 0)
 
 /** Check for additive overflow, setting an error if would occur. */
 #define GIT_MULTIPLY_SIZET_OVERFLOW(out, nelem, elsize) \
-	(git__multiply_sizet_overflow(out, nelem, elsize) ? (giterr_set_oom(), 1) : 0)
+	(git__multiply_sizet_overflow(out, nelem, elsize) ? (git_error_set_oom(), 1) : 0)
 
 /** Check for additive overflow, failing if it would occur. */
-#define GITERR_CHECK_ALLOC_ADD(out, one, two) \
+#define GIT_ERROR_CHECK_ALLOC_ADD(out, one, two) \
 	if (GIT_ADD_SIZET_OVERFLOW(out, one, two)) { return -1; }
 
-#define GITERR_CHECK_ALLOC_ADD3(out, one, two, three) \
+#define GIT_ERROR_CHECK_ALLOC_ADD3(out, one, two, three) \
 	if (GIT_ADD_SIZET_OVERFLOW(out, one, two) || \
 		GIT_ADD_SIZET_OVERFLOW(out, *(out), three)) { return -1; }
 
-#define GITERR_CHECK_ALLOC_ADD4(out, one, two, three, four) \
+#define GIT_ERROR_CHECK_ALLOC_ADD4(out, one, two, three, four) \
 	if (GIT_ADD_SIZET_OVERFLOW(out, one, two) || \
 		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) \
+#define GIT_ERROR_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) \
+#define GIT_ERROR_CHECK_ALLOC_MULTIPLY(out, nelem, elsize) \
 	if (GIT_MULTIPLY_SIZET_OVERFLOW(out, nelem, elsize)) { return -1; }
 
-/* NOTE: other giterr functions are in the public errors.h header file */
+/* NOTE: other git_error functions are in the public errors.h header file */
 
 #include "util.h"
 

data/vendor/libgit2/src/config.c

@@ -12,7 +12,7 @@
 #include "git2/sys/config.h"
 #include "vector.h"
 #include "buf_text.h"
-#include "config_file.h"
+#include "config_backend.h"
 #include "transaction.h"
 #if GIT_WIN32
 # include <windows.h>
@@ -31,30 +31,30 @@ void git_config_entry_free(git_config_entry *entry)
 typedef struct {
 	git_refcount rc;
 
-	git_config_backend *file;
+	git_config_backend *backend;
 	git_config_level_t level;
-} file_internal;
+} backend_internal;
 
-static void file_internal_free(file_internal *internal)
+static void backend_internal_free(backend_internal *internal)
 {
-	git_config_backend *file;
+	git_config_backend *backend;
 
-	file = internal->file;
-	file->free(file);
+	backend = internal->backend;
+	backend->free(backend);
 	git__free(internal);
 }
 
 static void config_free(git_config *cfg)
 {
 	size_t i;
-	file_internal *internal;
+	backend_internal *internal;
 
-	for (i = 0; i < cfg->files.length; ++i) {
-		internal = git_vector_get(&cfg->files, i);
-		GIT_REFCOUNT_DEC(internal, file_internal_free);
+	for (i = 0; i < cfg->backends.length; ++i) {
+		internal = git_vector_get(&cfg->backends, i);
+		GIT_REFCOUNT_DEC(internal, backend_internal_free);
 	}
 
-	git_vector_free(&cfg->files);
+	git_vector_free(&cfg->backends);
 
 	git__memzero(cfg, sizeof(*cfg));
 	git__free(cfg);
@@ -70,8 +70,8 @@ void git_config_free(git_config *cfg)
 
 static int config_backend_cmp(const void *a, const void *b)
 {
-	const file_internal *bk_a = (const file_internal *)(a);
-	const file_internal *bk_b = (const file_internal *)(b);
+	const backend_internal *bk_a = (const backend_internal *)(a);
+	const backend_internal *bk_b = (const backend_internal *)(b);
 
 	return bk_b->level - bk_a->level;
 }
@@ -81,11 +81,11 @@ int git_config_new(git_config **out)
 	git_config *cfg;
 
 	cfg = git__malloc(sizeof(git_config));
-	GITERR_CHECK_ALLOC(cfg);
+	GIT_ERROR_CHECK_ALLOC(cfg);
 
 	memset(cfg, 0x0, sizeof(git_config));
 
-	if (git_vector_init(&cfg->files, 3, config_backend_cmp) < 0) {
+	if (git_vector_init(&cfg->backends, 3, config_backend_cmp) < 0) {
 		git__free(cfg);
 		return -1;
 	}
@@ -110,11 +110,11 @@ int git_config_add_file_ondisk(
 
 	res = p_stat(path, &st);
 	if (res < 0 && errno != ENOENT && errno != ENOTDIR) {
-		giterr_set(GITERR_CONFIG, "failed to stat '%s'", path);
+		git_error_set(GIT_ERROR_CONFIG, "failed to stat '%s'", path);
 		return -1;
 	}
 
-	if (git_config_file__ondisk(&file, path) < 0)
+	if (git_config_backend_from_file(&file, path) < 0)
 		return -1;
 
 	if ((res = git_config_add_backend(cfg, file, level, repo, force)) < 0) {
@@ -151,7 +151,7 @@ int git_config_snapshot(git_config **out, git_config *in)
 {
 	int error = 0;
 	size_t i;
-	file_internal *internal;
+	backend_internal *internal;
 	git_config *config;
 
 	*out = NULL;
@@ -159,10 +159,10 @@ int git_config_snapshot(git_config **out, git_config *in)
 	if (git_config_new(&config) < 0)
 		return -1;
 
-	git_vector_foreach(&in->files, i, internal) {
+	git_vector_foreach(&in->backends, i, internal) {
 		git_config_backend *b;
 
-		if ((error = internal->file->snapshot(&b, internal->file)) < 0)
+		if ((error = internal->backend->snapshot(&b, internal->backend)) < 0)
 			break;
 
 		if ((error = git_config_add_backend(config, b, internal->level, NULL, 0)) < 0) {
@@ -179,59 +179,59 @@ int git_config_snapshot(git_config **out, git_config *in)
 	return error;
 }
 
-static int find_internal_file_by_level(
-	file_internal **internal_out,
+static int find_backend_by_level(
+	backend_internal **out,
 	const git_config *cfg,
 	git_config_level_t level)
 {
 	int pos = -1;
-	file_internal *internal;
+	backend_internal *internal;
 	size_t i;
 
-	/* when passing GIT_CONFIG_HIGHEST_LEVEL, the idea is to get the config file
-	 * which has the highest level. As config files are stored in a vector
-	 * sorted by decreasing order of level, getting the file at position 0
+	/* when passing GIT_CONFIG_HIGHEST_LEVEL, the idea is to get the config backend
+	 * which has the highest level. As config backends are stored in a vector
+	 * sorted by decreasing order of level, getting the backend at position 0
 	 * will do the job.
 	 */
 	if (level == GIT_CONFIG_HIGHEST_LEVEL) {
 		pos = 0;
 	} else {
-		git_vector_foreach(&cfg->files, i, internal) {
+		git_vector_foreach(&cfg->backends, i, internal) {
 			if (internal->level == level)
 				pos = (int)i;
 		}
 	}
 
 	if (pos == -1) {
-		giterr_set(GITERR_CONFIG,
-			"no config file exists for the given level '%i'", (int)level);
+		git_error_set(GIT_ERROR_CONFIG,
+			"no configuration exists for the given level '%i'", (int)level);
 		return GIT_ENOTFOUND;
 	}
 
-	*internal_out = git_vector_get(&cfg->files, pos);
+	*out = git_vector_get(&cfg->backends, pos);
 
 	return 0;
 }
 
 static int duplicate_level(void **old_raw, void *new_raw)
 {
-	file_internal **old = (file_internal **)old_raw;
+	backend_internal **old = (backend_internal **)old_raw;
 
 	GIT_UNUSED(new_raw);
 
-	giterr_set(GITERR_CONFIG, "a file with the same level (%i) has already been added to the config", (int)(*old)->level);
+	git_error_set(GIT_ERROR_CONFIG, "there already exists a configuration for the given level (%i)", (int)(*old)->level);
 	return GIT_EEXISTS;
 }
 
-static void try_remove_existing_file_internal(
+static void try_remove_existing_backend(
 	git_config *cfg,
 	git_config_level_t level)
 {
 	int pos = -1;
-	file_internal *internal;
+	backend_internal *internal;
 	size_t i;
 
-	git_vector_foreach(&cfg->files, i, internal) {
+	git_vector_foreach(&cfg->backends, i, internal) {
 		if (internal->level == level)
 			pos = (int)i;
 	}
@@ -239,32 +239,32 @@ static void try_remove_existing_file_internal(
 	if (pos == -1)
 		return;
 
-	internal = git_vector_get(&cfg->files, pos);
+	internal = git_vector_get(&cfg->backends, pos);
 
-	if (git_vector_remove(&cfg->files, pos) < 0)
+	if (git_vector_remove(&cfg->backends, pos) < 0)
 		return;
 
-	GIT_REFCOUNT_DEC(internal, file_internal_free);
+	GIT_REFCOUNT_DEC(internal, backend_internal_free);
 }
 
 static int git_config__add_internal(
 	git_config *cfg,
-	file_internal *internal,
+	backend_internal *internal,
 	git_config_level_t level,
 	int force)
 {
 	int result;
 
-	/* delete existing config file for level if it exists */
+	/* delete existing config backend for level if it exists */
 	if (force)
-		try_remove_existing_file_internal(cfg, level);
+		try_remove_existing_backend(cfg, level);
 
-	if ((result = git_vector_insert_sorted(&cfg->files,
+	if ((result = git_vector_insert_sorted(&cfg->backends,
 			internal, &duplicate_level)) < 0)
 		return result;
 
-	git_vector_sort(&cfg->files);
-	internal->file->cfg = cfg;
+	git_vector_sort(&cfg->backends);
+	internal->backend->cfg = cfg;
 
 	GIT_REFCOUNT_INC(internal);
 
@@ -285,10 +285,10 @@ int git_config_open_level(
 	git_config_level_t level)
 {
 	git_config *cfg;
-	file_internal *internal;
+	backend_internal *internal;
 	int res;
 
-	if ((res = find_internal_file_by_level(&internal, cfg_parent, level)) < 0)
+	if ((res = find_backend_by_level(&internal, cfg_parent, level)) < 0)
 		return res;
 
 	if ((res = git_config_new(&cfg)) < 0)
@@ -306,27 +306,27 @@ int git_config_open_level(
 
 int git_config_add_backend(
 	git_config *cfg,
-	git_config_backend *file,
+	git_config_backend *backend,
 	git_config_level_t level,
 	const git_repository *repo,
 	int force)
 {
-	file_internal *internal;
+	backend_internal *internal;
 	int result;
 
-	assert(cfg && file);
+	assert(cfg && backend);
 
-	GITERR_CHECK_VERSION(file, GIT_CONFIG_BACKEND_VERSION, "git_config_backend");
+	GIT_ERROR_CHECK_VERSION(backend, GIT_CONFIG_BACKEND_VERSION, "git_config_backend");
 
-	if ((result = file->open(file, level, repo)) < 0)
+	if ((result = backend->open(backend, level, repo)) < 0)
 		return result;
 
-	internal = git__malloc(sizeof(file_internal));
-	GITERR_CHECK_ALLOC(internal);
+	internal = git__malloc(sizeof(backend_internal));
+	GIT_ERROR_CHECK_ALLOC(internal);
 
-	memset(internal, 0x0, sizeof(file_internal));
+	memset(internal, 0x0, sizeof(backend_internal));
 
-	internal->file = file;
+	internal->backend = backend;
 	internal->level = level;
 
 	if ((result = git_config__add_internal(cfg, internal, level, force)) < 0) {
@@ -351,11 +351,11 @@ typedef struct {
 
 static int find_next_backend(size_t *out, const git_config *cfg, size_t i)
 {
-	file_internal *internal;
+	backend_internal *internal;
 
 	for (; i > 0; --i) {
-		internal = git_vector_get(&cfg->files, i - 1);
-		if (!internal || !internal->file)
+		internal = git_vector_get(&cfg->backends, i - 1);
+		if (!internal || !internal->backend)
 			continue;
 
 		*out = i;
@@ -368,7 +368,7 @@ static int find_next_backend(size_t *out, const git_config *cfg, size_t i)
 static int all_iter_next(git_config_entry **entry, git_config_iterator *_iter)
 {
 	all_iter *iter = (all_iter *) _iter;
-	file_internal *internal;
+	backend_internal *internal;
 	git_config_backend *backend;
 	size_t i;
 	int error = 0;
@@ -385,8 +385,8 @@ static int all_iter_next(git_config_entry **entry, git_config_iterator *_iter)
 		if (find_next_backend(&i, iter->cfg, iter->i) < 0)
 			return GIT_ITEROVER;
 
-		internal = git_vector_get(&iter->cfg->files, i - 1);
-		backend = internal->file;
+		internal = git_vector_get(&iter->cfg->backends, i - 1);
+		backend = internal->backend;
 		iter->i = i - 1;
 
 		if (iter->current)
@@ -456,12 +456,12 @@ int git_config_iterator_new(git_config_iterator **out, const git_config *cfg)
 	all_iter *iter;
 
 	iter = git__calloc(1, sizeof(all_iter));
-	GITERR_CHECK_ALLOC(iter);
+	GIT_ERROR_CHECK_ALLOC(iter);
 
 	iter->parent.free = all_iter_free;
 	iter->parent.next = all_iter_next;
 
-	iter->i = cfg->files.length;
+	iter->i = cfg->backends.length;
 	iter->cfg = cfg;
 
 	*out = (git_config_iterator *) iter;
@@ -478,17 +478,17 @@ int git_config_iterator_glob_new(git_config_iterator **out, const git_config *cf
 		return git_config_iterator_new(out, cfg);
 
 	iter = git__calloc(1, sizeof(all_iter));
-	GITERR_CHECK_ALLOC(iter);
+	GIT_ERROR_CHECK_ALLOC(iter);
 
 	if ((result = p_regcomp(&iter->regex, regexp, REG_EXTENDED)) != 0) {
-		giterr_set_regex(&iter->regex, result);
+		git_error_set_regex(&iter->regex, result);
 		git__free(iter);
 		return -1;
 	}
 
 	iter->parent.next = all_iter_glob_next;
 	iter->parent.free = all_iter_glob_free;
-	iter->i = cfg->files.length;
+	iter->i = cfg->backends.length;
 	iter->cfg = cfg;
 
 	*out = (git_config_iterator *) iter;
@@ -517,7 +517,7 @@ int git_config_backend_foreach_match(
 
 	if (regexp != NULL) {
 		if ((error = p_regcomp(&regex, regexp, REG_EXTENDED)) != 0) {
-			giterr_set_regex(&regex, error);
+			git_error_set_regex(&regex, error);
 			regfree(&regex);
 			return -1;
 		}
@@ -535,7 +535,7 @@ int git_config_backend_foreach_match(
 
 		/* abort iterator on non-zero return value */
 		if ((error = cb(entry, payload)) != 0) {
-			giterr_set_after_callback(error);
+			git_error_set_after_callback(error);
 			break;
 		}
 	}
@@ -563,7 +563,7 @@ int git_config_foreach_match(
 
 	while (!(error = git_config_next(&entry, iter))) {
 		if ((error = cb(entry, payload)) != 0) {
-			giterr_set_after_callback(error);
+			git_error_set_after_callback(error);
 			break;
 		}
 	}
@@ -594,38 +594,38 @@ static int get_backend_for_use(git_config_backend **out,
 	git_config *cfg, const char *name, backend_use use)
 {
 	size_t i;
-	file_internal *f;
+	backend_internal *backend;
 
 	*out = NULL;
 
-	if (git_vector_length(&cfg->files) == 0) {
-		giterr_set(GITERR_CONFIG,
-			"cannot %s value for '%s' when no config files exist",
+	if (git_vector_length(&cfg->backends) == 0) {
+		git_error_set(GIT_ERROR_CONFIG,
+			"cannot %s value for '%s' when no config backends exist",
 			uses[use], name);
 		return GIT_ENOTFOUND;
 	}
 
-	git_vector_foreach(&cfg->files, i, f) {
-		if (!f->file->readonly) {
-			*out = f->file;
+	git_vector_foreach(&cfg->backends, i, backend) {
+		if (!backend->backend->readonly) {
+			*out = backend->backend;
 			return 0;
 		}
 	}
 
-	giterr_set(GITERR_CONFIG,
-		"cannot %s value for '%s' when all config files are readonly",
+	git_error_set(GIT_ERROR_CONFIG,
+		"cannot %s value for '%s' when all config backends are readonly",
 		uses[use], name);
 	return GIT_ENOTFOUND;
 }
 
 int git_config_delete_entry(git_config *cfg, const char *name)
 {
-	git_config_backend *file;
+	git_config_backend *backend;
 
-	if (get_backend_for_use(&file, cfg, name, BACKEND_USE_DELETE) < 0)
+	if (get_backend_for_use(&backend, cfg, name, BACKEND_USE_DELETE) < 0)
 		return GIT_ENOTFOUND;
 
-	return file->del(file, name);
+	return backend->del(backend, name);
 }
 
 int git_config_set_int64(git_config *cfg, const char *name, int64_t value)
@@ -648,17 +648,17 @@ int git_config_set_bool(git_config *cfg, const char *name, int value)
 int git_config_set_string(git_config *cfg, const char *name, const char *value)
 {
 	int error;
-	git_config_backend *file;
+	git_config_backend *backend;
 
 	if (!value) {
-		giterr_set(GITERR_CONFIG, "the value to set cannot be NULL");
+		git_error_set(GIT_ERROR_CONFIG, "the value to set cannot be NULL");
 		return -1;
 	}
 
-	if (get_backend_for_use(&file, cfg, name, BACKEND_USE_SET) < 0)
+	if (get_backend_for_use(&backend, cfg, name, BACKEND_USE_SET) < 0)
 		return GIT_ENOTFOUND;
 
-	error = file->set(file, name, value);
+	error = backend->set(backend, name, value);
 
 	if (!error && GIT_REFCOUNT_OWNER(cfg) != NULL)
 		git_repository__cvar_cache_clear(GIT_REFCOUNT_OWNER(cfg));
@@ -703,7 +703,7 @@ int git_config__update_entry(
 
 static int config_error_notfound(const char *name)
 {
-	giterr_set(GITERR_CONFIG, "config value '%s' was not found", name);
+	git_error_set(GIT_ERROR_CONFIG, "config value '%s' was not found", name);
 	return GIT_ENOTFOUND;
 }
 
@@ -724,7 +724,7 @@ static int get_entry(
 	const char *key = name;
 	char *normalized = NULL;
 	size_t i;
-	file_internal *internal;
+	backend_internal *internal;
 
 	*out = NULL;
 
@@ -735,11 +735,11 @@ static int get_entry(
 	}
 
 	res = GIT_ENOTFOUND;
-	git_vector_foreach(&cfg->files, i, internal) {
-		if (!internal || !internal->file)
+	git_vector_foreach(&cfg->backends, i, internal) {
+		if (!internal || !internal->backend)
 			continue;
 
-		res = internal->file->get(internal->file, key, out);
+		res = internal->backend->get(internal->backend, key, out);
 		if (res != GIT_ENOTFOUND)
 			break;
 	}
@@ -750,7 +750,7 @@ cleanup:
 	if (res == GIT_ENOTFOUND)
 		res = (want_errors > GET_ALL_ERRORS) ? 0 : config_error_notfound(name);
 	else if (res && (want_errors == GET_NO_ERRORS)) {
-		giterr_clear();
+		git_error_clear();
 		res = 0;
 	}
 
@@ -837,13 +837,13 @@ int git_config_get_bool(int *out, const git_config *cfg, const char *name)
 static int is_readonly(const git_config *cfg)
 {
 	size_t i;
-	file_internal *internal;
+	backend_internal *internal;
 
-	git_vector_foreach(&cfg->files, i, internal) {
-		if (!internal || !internal->file)
+	git_vector_foreach(&cfg->backends, i, internal) {
+		if (!internal || !internal->backend)
 			continue;
 
-		if (!internal->file->readonly)
+		if (!internal->backend->readonly)
 			return 0;
 	}
 
@@ -871,7 +871,7 @@ int git_config_get_string(
 	int ret;
 
 	if (!is_readonly(cfg)) {
-		giterr_set(GITERR_CONFIG, "get_string called on a live config object");
+		git_error_set(GIT_ERROR_CONFIG, "get_string called on a live config object");
 		return -1;
 	}
 
@@ -925,7 +925,7 @@ int git_config__get_bool_force(
 	get_entry(&entry, cfg, key, false, GET_NO_ERRORS);
 
 	if (entry && git_config_parse_bool(&val, entry->value) < 0)
-		giterr_clear();
+		git_error_clear();
 
 	git_config_entry_free(entry);
 	return val;
@@ -940,7 +940,7 @@ int git_config__get_int_force(
 	get_entry(&entry, cfg, key, false, GET_NO_ERRORS);
 
 	if (entry && git_config_parse_int32(&val, entry->value) < 0)
-		giterr_clear();
+		git_error_clear();
 
 	git_config_entry_free(entry);
 	return (int)val;
@@ -962,7 +962,7 @@ int git_config_get_multivar_foreach(
 		found = 1;
 
 		if ((err = cb(entry, payload)) != 0) {
-			giterr_set_after_callback(err);
+			git_error_set_after_callback(err);
 			break;
 		}
 	}
@@ -1026,7 +1026,7 @@ int git_config_multivar_iterator_new(git_config_iterator **out, const git_config
 		return error;
 
 	iter = git__calloc(1, sizeof(multivar_iter));
-	GITERR_CHECK_ALLOC(iter);
+	GIT_ERROR_CHECK_ALLOC(iter);
 
 	if ((error = git_config__normalize_name(name, &iter->name)) < 0)
 		goto on_error;
@@ -1034,7 +1034,7 @@ int git_config_multivar_iterator_new(git_config_iterator **out, const git_config
 	if (regexp != NULL) {
 		error = p_regcomp(&iter->regex, regexp, REG_EXTENDED);
 		if (error != 0) {
-			giterr_set_regex(&iter->regex, error);
+			git_error_set_regex(&iter->regex, error);
 			error = -1;
 			regfree(&iter->regex);
 			goto on_error;
@@ -1060,22 +1060,22 @@ on_error:
 
 int git_config_set_multivar(git_config *cfg, const char *name, const char *regexp, const char *value)
 {
-	git_config_backend *file;
+	git_config_backend *backend;
 
-	if (get_backend_for_use(&file, cfg, name, BACKEND_USE_DELETE) < 0)
+	if (get_backend_for_use(&backend, cfg, name, BACKEND_USE_DELETE) < 0)
 		return GIT_ENOTFOUND;
 
-	return file->set_multivar(file, name, regexp, value);
+	return backend->set_multivar(backend, name, regexp, value);
 }
 
 int git_config_delete_multivar(git_config *cfg, const char *name, const char *regexp)
 {
-	git_config_backend *file;
+	git_config_backend *backend;
 
-	if (get_backend_for_use(&file, cfg, name, BACKEND_USE_DELETE) < 0)
+	if (get_backend_for_use(&backend, cfg, name, BACKEND_USE_DELETE) < 0)
 		return GIT_ENOTFOUND;
 
-	return file->del_multivar(file, name, regexp);
+	return backend->del_multivar(backend, name, regexp);
 }
 
 int git_config_next(git_config_entry **entry, git_config_iterator *iter)
@@ -1111,15 +1111,8 @@ int git_config_find_system(git_buf *path)
 
 int git_config_find_programdata(git_buf *path)
 {
-	int ret;
-
 	git_buf_sanitize(path);
-	ret = git_sysdir_find_programdata_file(path,
-					       GIT_CONFIG_FILENAME_PROGRAMDATA);
-	if (ret != GIT_OK)
-		return ret;
-
-	return git_path_validate_system_file_ownership(path->ptr);
+	return git_sysdir_find_programdata_file(path, GIT_CONFIG_FILENAME_PROGRAMDATA);
 }
 
 int git_config__global_location(git_buf *buf)
@@ -1173,7 +1166,7 @@ int git_config_open_default(git_config **out)
 		error = git_config_add_file_ondisk(cfg, buf.ptr,
 			GIT_CONFIG_LEVEL_PROGRAMDATA, NULL, 0);
 
-	git_buf_free(&buf);
+	git_buf_dispose(&buf);
 
 	if (error) {
 		git_config_free(cfg);
@@ -1188,17 +1181,19 @@ int git_config_open_default(git_config **out)
 int git_config_lock(git_transaction **out, git_config *cfg)
 {
 	int error;
-	git_config_backend *file;
-	file_internal *internal;
+	git_config_backend *backend;
+	backend_internal *internal;
+
+	assert(cfg);
 
-	internal = git_vector_get(&cfg->files, 0);
-	if (!internal || !internal->file) {
-		giterr_set(GITERR_CONFIG, "cannot lock; the config has no backends/files");
+	internal = git_vector_get(&cfg->backends, 0);
+	if (!internal || !internal->backend) {
+		git_error_set(GIT_ERROR_CONFIG, "cannot lock; the config has no backends");
 		return -1;
 	}
-	file = internal->file;
+	backend = internal->backend;
 
-	if ((error = file->lock(file)) < 0)
+	if ((error = backend->lock(backend)) < 0)
 		return error;
 
 	return git_transaction_config_new(out, cfg);
@@ -1206,18 +1201,20 @@ int git_config_lock(git_transaction **out, git_config *cfg)
 
 int git_config_unlock(git_config *cfg, int commit)
 {
-	git_config_backend *file;
-	file_internal *internal;
+	git_config_backend *backend;
+	backend_internal *internal;
+
+	assert(cfg);
 
-	internal = git_vector_get(&cfg->files, 0);
-	if (!internal || !internal->file) {
-		giterr_set(GITERR_CONFIG, "cannot lock; the config has no backends/files");
+	internal = git_vector_get(&cfg->backends, 0);
+	if (!internal || !internal->backend) {
+		git_error_set(GIT_ERROR_CONFIG, "cannot lock; the config has no backends");
 		return -1;
 	}
 
-	file = internal->file;
+	backend = internal->backend;
 
-	return file->unlock(file, commit);
+	return backend->unlock(backend, commit);
 }
 
 /***********
@@ -1266,7 +1263,7 @@ int git_config_lookup_map_value(
 	}
 
 fail_parse:
-	giterr_set(GITERR_CONFIG, "failed to map '%s'", value);
+	git_error_set(GIT_ERROR_CONFIG, "failed to map '%s'", value);
 	return -1;
 }
 
@@ -1286,7 +1283,7 @@ int git_config_lookup_map_enum(git_cvar_t *type_out, const char **str_out,
 		return 0;
 	}
 
-	giterr_set(GITERR_CONFIG, "invalid enum value");
+	git_error_set(GIT_ERROR_CONFIG, "invalid enum value");
 	return GIT_ENOTFOUND;
 }
 
@@ -1300,7 +1297,7 @@ int git_config_parse_bool(int *out, const char *value)
 		return 0;
 	}
 
-	giterr_set(GITERR_CONFIG, "failed to parse '%s' as a boolean value", value);
+	git_error_set(GIT_ERROR_CONFIG, "failed to parse '%s' as a boolean value", value);
 	return -1;
 }
 
@@ -1343,7 +1340,7 @@ int git_config_parse_int64(int64_t *out, const char *value)
 	}
 
 fail_parse:
-	giterr_set(GITERR_CONFIG, "failed to parse '%s' as an integer", value ? value : "(null)");
+	git_error_set(GIT_ERROR_CONFIG, "failed to parse '%s' as an integer", value ? value : "(null)");
 	return -1;
 }
 
@@ -1363,7 +1360,7 @@ int git_config_parse_int32(int32_t *out, const char *value)
 	return 0;
 
 fail_parse:
-	giterr_set(GITERR_CONFIG, "failed to parse '%s' as a 32-bit integer", value ? value : "(null)");
+	git_error_set(GIT_ERROR_CONFIG, "failed to parse '%s' as a 32-bit integer", value ? value : "(null)");
 	return -1;
 }
 
@@ -1375,7 +1372,7 @@ int git_config_parse_path(git_buf *out, const char *value)
 
 	if (value[0] == '~') {
 		if (value[1] != '\0' && value[1] != '/') {
-			giterr_set(GITERR_CONFIG, "retrieving a homedir by name is not supported");
+			git_error_set(GIT_ERROR_CONFIG, "retrieving a homedir by name is not supported");
 			return -1;
 		}
 
@@ -1385,6 +1382,30 @@ int git_config_parse_path(git_buf *out, const char *value)
 	return git_buf_sets(out, value);
 }
 
+static int normalize_section(char *start, char *end)
+{
+	char *scan;
+
+	if (start == end)
+		return GIT_EINVALIDSPEC;
+
+	/* Validate and downcase range */
+	for (scan = start; *scan; ++scan) {
+		if (end && scan >= end)
+			break;
+		if (isalnum(*scan))
+			*scan = (char)git__tolower(*scan);
+		else if (*scan != '-' || scan == start)
+			return GIT_EINVALIDSPEC;
+	}
+
+	if (scan == start)
+		return GIT_EINVALIDSPEC;
+
+	return 0;
+}
+
+
 /* Take something the user gave us and make it nice for our hash function */
 int git_config__normalize_name(const char *in, char **out)
 {
@@ -1393,7 +1414,7 @@ int git_config__normalize_name(const char *in, char **out)
 	assert(in && out);
 
 	name = git__strdup(in);
-	GITERR_CHECK_ALLOC(name);
+	GIT_ERROR_CHECK_ALLOC(name);
 
 	fdot = strchr(name, '.');
 	ldot = strrchr(name, '.');
@@ -1402,8 +1423,8 @@ int git_config__normalize_name(const char *in, char **out)
 		goto invalid;
 
 	/* 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)
+	if (normalize_section(name, fdot) < 0 ||
+	    normalize_section(ldot + 1, NULL) < 0)
 		goto invalid;
 
 	/* If there is a middle range, make sure it doesn't have newlines */
@@ -1416,7 +1437,7 @@ int git_config__normalize_name(const char *in, char **out)
 
 invalid:
 	git__free(name);
-	giterr_set(GITERR_CONFIG, "invalid config item name '%s'", in);
+	git_error_set(GIT_ERROR_CONFIG, "invalid config item name '%s'", in);
 	return GIT_EINVALIDSPEC;
 }
 
@@ -1475,11 +1496,10 @@ int git_config_rename_section(
 		goto cleanup;
 
 	if (new_section_name != NULL &&
-		(error = git_config_file_normalize_section(
-			replace.ptr, strchr(replace.ptr, '.'))) < 0)
+	    (error = normalize_section(replace.ptr, strchr(replace.ptr, '.'))) < 0)
 	{
-		giterr_set(
-			GITERR_CONFIG, "invalid config section '%s'", new_section_name);
+		git_error_set(
+			GIT_ERROR_CONFIG, "invalid config section '%s'", new_section_name);
 		goto cleanup;
 	}
 
@@ -1487,8 +1507,8 @@ int git_config_rename_section(
 		config, git_buf_cstr(&pattern), rename_config_entries_cb, &data);
 
 cleanup:
-	git_buf_free(&pattern);
-	git_buf_free(&replace);
+	git_buf_dispose(&pattern);
+	git_buf_dispose(&replace);
 
 	return error;
 }