rugged 0.27.10.1 → 0.28.0

data/vendor/libgit2/src/pack.h

@@ -66,7 +66,7 @@ struct pack_chain_elem {
 	git_off_t base_key;
 	git_off_t offset;
 	size_t size;
-	git_otype type;
+	git_object_t type;
 };
 
 typedef git_array_t(struct pack_chain_elem) git_dependency_chain;
@@ -123,20 +123,20 @@ typedef struct git_packfile_stream {
 	git_mwindow *mw;
 } git_packfile_stream;
 
-size_t git_packfile__object_header(unsigned char *hdr, size_t size, git_otype type);
+size_t git_packfile__object_header(unsigned char *hdr, size_t size, git_object_t type);
 
 int git_packfile__name(char **out, const char *path);
 
 int git_packfile_unpack_header(
 		size_t *size_p,
-		git_otype *type_p,
+		git_object_t *type_p,
 		git_mwindow_file *mwf,
 		git_mwindow **w_curs,
 		git_off_t *curpos);
 
 int git_packfile_resolve_header(
 		size_t *size_p,
-		git_otype *type_p,
+		git_object_t *type_p,
 		struct git_pack_file *p,
 		git_off_t offset);
 
@@ -144,10 +144,10 @@ int git_packfile_unpack(git_rawobj *obj, struct git_pack_file *p, git_off_t *obj
 
 int git_packfile_stream_open(git_packfile_stream *obj, struct git_pack_file *p, git_off_t curpos);
 ssize_t git_packfile_stream_read(git_packfile_stream *obj, void *buffer, size_t len);
-void git_packfile_stream_free(git_packfile_stream *obj);
+void git_packfile_stream_dispose(git_packfile_stream *obj);
 
 git_off_t get_delta_base(struct git_pack_file *p, git_mwindow **w_curs,
-		git_off_t *curpos, git_otype type,
+		git_off_t *curpos, git_object_t type,
 		git_off_t delta_obj_offset);
 
 void git_packfile_close(struct git_pack_file *p, bool unlink_packfile);

data/vendor/libgit2/src/parse.h

@@ -27,7 +27,7 @@ int git_parse_ctx_init(git_parse_ctx *ctx, const char *content, size_t content_l
 void git_parse_ctx_clear(git_parse_ctx *ctx);
 
 #define git_parse_err(...) \
-	( giterr_set(GITERR_PATCH, __VA_ARGS__), -1 )
+	( git_error_set(GIT_ERROR_PATCH, __VA_ARGS__), -1 )
 
 #define git_parse_ctx_contains_s(ctx, str) \
 	git_parse_ctx_contains(ctx, str, sizeof(str) - 1)

data/vendor/libgit2/src/patch.c

@@ -80,11 +80,11 @@ size_t git_patch_size(
 
 		if (git_diff_delta__format_file_header(
 			&file_header, patch->delta, NULL, NULL, 0) < 0)
-			giterr_clear();
+			git_error_clear();
 		else
 			out += git_buf_len(&file_header);
 
-		git_buf_free(&file_header);
+		git_buf_dispose(&file_header);
 	}
 
 	return out;
@@ -141,7 +141,7 @@ size_t git_patch_num_hunks(const git_patch *patch)
 
 static int patch_error_outofrange(const char *thing)
 {
-	giterr_set(GITERR_INVALID, "patch %s index out of range", thing);
+	git_error_set(GIT_ERROR_INVALID, "patch %s index out of range", thing);
 	return GIT_ENOTFOUND;
 }
 

data/vendor/libgit2/src/patch_generate.c

@@ -84,7 +84,7 @@ static int patch_generated_normalize_options(
 	const git_diff_options *opts)
 {
 	if (opts) {
-		GITERR_CHECK_VERSION(opts, GIT_DIFF_OPTIONS_VERSION, "git_diff_options");
+		GIT_ERROR_CHECK_VERSION(opts, GIT_DIFF_OPTIONS_VERSION, "git_diff_options");
 		memcpy(out, opts, sizeof(git_diff_options));
 	} else {
 		git_diff_options default_opts = GIT_DIFF_OPTIONS_INIT;
@@ -99,8 +99,8 @@ static int patch_generated_normalize_options(
 		git__strdup(opts->new_prefix) :
 		git__strdup(DIFF_NEW_PREFIX_DEFAULT);
 
-	GITERR_CHECK_ALLOC(out->old_prefix);
-	GITERR_CHECK_ALLOC(out->new_prefix);
+	GIT_ERROR_CHECK_ALLOC(out->old_prefix);
+	GIT_ERROR_CHECK_ALLOC(out->new_prefix);
 
 	return 0;
 }
@@ -135,7 +135,7 @@ static int patch_generated_alloc_from_diff(
 {
 	int error;
 	git_patch_generated *patch = git__calloc(1, sizeof(git_patch_generated));
-	GITERR_CHECK_ALLOC(patch);
+	GIT_ERROR_CHECK_ALLOC(patch);
 
 	if (!(error = patch_generated_init(patch, diff, delta_index))) {
 		patch->flags |= GIT_PATCH_GENERATED_ALLOCATED;
@@ -248,7 +248,7 @@ static int patch_generated_invoke_file_callback(
 	if (!output->file_cb)
 		return 0;
 
-	return giterr_set_after_callback_function(
+	return git_error_set_after_callback_function(
 		output->file_cb(patch->base.delta, progress, output->payload),
 		"git_patch");
 }
@@ -314,8 +314,8 @@ static int create_binary(
 	}
 
 done:
-	git_buf_free(&deflate);
-	git_buf_free(&delta);
+	git_buf_dispose(&deflate);
+	git_buf_dispose(&delta);
 
 	return error;
 }
@@ -350,7 +350,7 @@ static int diff_binary(git_patch_generated_output *output, git_patch_generated *
 			return error;
 	}
 
-	error = giterr_set_after_callback_function(
+	error = git_error_set_after_callback_function(
 		output->binary_cb(patch->base.delta, &binary, output->payload),
 		"git_patch");
 
@@ -397,7 +397,7 @@ static int diff_required(git_diff *diff, const char *action)
 {
 	if (diff)
 		return 0;
-	giterr_set(GITERR_INVALID, "must provide valid diff to %s", action);
+	git_error_set(GIT_ERROR_INVALID, "must provide valid diff to %s", action);
 	return -1;
 }
 
@@ -501,12 +501,12 @@ static int patch_generated_with_delta_alloc(
 	size_t new_len = *new_path ? strlen(*new_path) : 0;
 	size_t alloc_len;
 
-	GITERR_CHECK_ALLOC_ADD(&alloc_len, sizeof(*pd), old_len);
-	GITERR_CHECK_ALLOC_ADD(&alloc_len, alloc_len, new_len);
-	GITERR_CHECK_ALLOC_ADD(&alloc_len, alloc_len, 2);
+	GIT_ERROR_CHECK_ALLOC_ADD(&alloc_len, sizeof(*pd), old_len);
+	GIT_ERROR_CHECK_ALLOC_ADD(&alloc_len, alloc_len, new_len);
+	GIT_ERROR_CHECK_ALLOC_ADD(&alloc_len, alloc_len, 2);
 
 	*out = pd = git__calloc(1, alloc_len);
-	GITERR_CHECK_ALLOC(pd);
+	GIT_ERROR_CHECK_ALLOC(pd);
 
 	pd->patch.flags = GIT_PATCH_GENERATED_ALLOCATED;
 
@@ -708,7 +708,7 @@ int git_patch_generated_from_diff(
 
 	delta = git_vector_get(&diff->deltas, idx);
 	if (!delta) {
-		giterr_set(GITERR_INVALID, "index out of range for delta in diff");
+		git_error_set(GIT_ERROR_INVALID, "index out of range for delta in diff");
 		return GIT_ENOTFOUND;
 	}
 
@@ -788,7 +788,7 @@ static int patch_generated_binary_cb(
 
 	if (binary->old_file.data) {
 		patch->binary.old_file.data = git__malloc(binary->old_file.datalen);
-		GITERR_CHECK_ALLOC(patch->binary.old_file.data);
+		GIT_ERROR_CHECK_ALLOC(patch->binary.old_file.data);
 
 		memcpy((char *)patch->binary.old_file.data,
 			binary->old_file.data, binary->old_file.datalen);
@@ -796,7 +796,7 @@ static int patch_generated_binary_cb(
 
 	if (binary->new_file.data) {
 		patch->binary.new_file.data = git__malloc(binary->new_file.datalen);
-		GITERR_CHECK_ALLOC(patch->binary.new_file.data);
+		GIT_ERROR_CHECK_ALLOC(patch->binary.new_file.data);
 
 		memcpy((char *)patch->binary.new_file.data,
 			binary->new_file.data, binary->new_file.datalen);
@@ -816,7 +816,7 @@ static int git_patch_hunk_cb(
 	GIT_UNUSED(delta);
 
 	hunk = git_array_alloc(patch->base.hunks);
-	GITERR_CHECK_ALLOC(hunk);
+	GIT_ERROR_CHECK_ALLOC(hunk);
 
 	memcpy(&hunk->hunk, hunk_, sizeof(hunk->hunk));
 
@@ -845,7 +845,7 @@ static int patch_generated_line_cb(
 	assert(hunk); /* programmer error if no hunk is available */
 
 	line = git_array_alloc(patch->base.lines);
-	GITERR_CHECK_ALLOC(line);
+	GIT_ERROR_CHECK_ALLOC(line);
 
 	memcpy(line, line_, sizeof(*line));
 

data/vendor/libgit2/src/patch_parse.c

@@ -98,7 +98,7 @@ static int parse_header_git_oldpath(
 	patch->old_path = git_buf_detach(&old_path);
 
 out:
-	git_buf_free(&old_path);
+	git_buf_dispose(&old_path);
 	return error;
 }
 
@@ -114,7 +114,7 @@ static int parse_header_git_newpath(
 	patch->new_path = git_buf_detach(&new_path);
 
 out:
-	git_buf_free(&new_path);
+	git_buf_dispose(&new_path);
 	return error;
 }
 
@@ -282,7 +282,7 @@ static int parse_header_percent(uint16_t *out, git_patch_parse_ctx *ctx)
 	if (val < 0 || val > 100)
 		return -1;
 
-	*out = val;
+	*out = (uint16_t)val;
 	return 0;
 }
 
@@ -518,7 +518,7 @@ static int parse_hunk_header(
 	return 0;
 
 fail:
-	giterr_set(GITERR_PATCH, "invalid patch hunk header at line %"PRIuZ,
+	git_error_set(GIT_ERROR_PATCH, "invalid patch hunk header at line %"PRIuZ,
 		ctx->parse_ctx.line_num);
 	return -1;
 }
@@ -583,7 +583,7 @@ static int parse_hunk_body(
 		}
 
 		line = git_array_alloc(patch->base.lines);
-		GITERR_CHECK_ALLOC(line);
+		GIT_ERROR_CHECK_ALLOC(line);
 
 		memset(line, 0x0, sizeof(git_diff_line));
 
@@ -650,7 +650,7 @@ static int parse_patch_header(
 			* noise, continue.
 			*/
 			if (parse_hunk_header(&hunk, ctx) < 0) {
-				giterr_clear();
+				git_error_clear();
 				continue;
 			}
 
@@ -673,7 +673,7 @@ static int parse_patch_header(
 		continue;
 	}
 
-	giterr_set(GITERR_PATCH, "no patch found");
+	git_error_set(GIT_ERROR_PATCH, "no patch found");
 	error = GIT_ENOTFOUND;
 
 done:
@@ -757,8 +757,8 @@ static int parse_patch_binary_side(
 	binary->data = git_buf_detach(&decoded);
 
 done:
-	git_buf_free(&base85);
-	git_buf_free(&decoded);
+	git_buf_dispose(&base85);
+	git_buf_dispose(&decoded);
 	return error;
 }
 
@@ -821,7 +821,7 @@ static int parse_patch_hunks(
 
 	while (git_parse_ctx_contains_s(&ctx->parse_ctx, "@@ -")) {
 		hunk = git_array_alloc(patch->base.hunks);
-		GITERR_CHECK_ALLOC(hunk);
+		GIT_ERROR_CHECK_ALLOC(hunk);
 
 		memset(hunk, 0, sizeof(git_patch_hunk));
 
@@ -1079,7 +1079,7 @@ int git_patch_parse(
 	*out = NULL;
 
 	patch = git__calloc(1, sizeof(git_patch_parsed));
-	GITERR_CHECK_ALLOC(patch);
+	GIT_ERROR_CHECK_ALLOC(patch);
 
 	patch->ctx = ctx;
 	GIT_REFCOUNT_INC(patch->ctx);
@@ -1087,7 +1087,7 @@ int git_patch_parse(
 	patch->base.free_fn = patch_parsed__free;
 
 	patch->base.delta = git__calloc(1, sizeof(git_diff_delta));
-	GITERR_CHECK_ALLOC(patch->base.delta);
+	GIT_ERROR_CHECK_ALLOC(patch->base.delta);
 
 	patch->base.delta->status = GIT_DELTA_MODIFIED;
 	patch->base.delta->nfiles = 2;
@@ -1126,7 +1126,7 @@ int git_patch_from_buffer(
 	int error;
 
 	ctx = git_patch_parse_ctx_init(content, content_len, opts);
-	GITERR_CHECK_ALLOC(ctx);
+	GIT_ERROR_CHECK_ALLOC(ctx);
 
 	error = git_patch_parse(out, ctx);
 

data/vendor/libgit2/src/path.c

@@ -14,36 +14,13 @@
 #include "win32/w32_buffer.h"
 #include "win32/w32_util.h"
 #include "win32/version.h"
-#include <AclAPI.h>
 #else
 #include <dirent.h>
 #endif
 #include <stdio.h>
 #include <ctype.h>
 
-static int dos_drive_prefix_length(const char *path)
-{
-	int i;
-
-	/*
-	 * Does it start with an ASCII letter (i.e. highest bit not set),
-	 * followed by a colon?
-	 */
-	if (!(0x80 & (unsigned char)*path))
-		return *path && path[1] == ':' ? 2 : 0;
-
-	/*
-	 * While drive letters must be letters of the English alphabet, it is
-	 * possible to assign virtually _any_ Unicode character via `subst` as
-	 * a drive letter to "virtual drives". Even `1`, or `ä`. Or fun stuff
-	 * like this:
-	 *
-	 *	subst ֍: %USERPROFILE%\Desktop
-	 */
-	for (i = 1; i < 4 && (0x80 & (unsigned char)path[i]); i++)
-		; /* skip first UTF-8 character */
-	return path[i] == ':' ? i + 1 : 0;
-}
+#define LOOKS_LIKE_DRIVE_PREFIX(S) (git__isalpha((S)[0]) && (S)[1] == ':')
 
 #ifdef GIT_WIN32
 static bool looks_like_network_computer_name(const char *path, int pos)
@@ -145,11 +122,11 @@ static int win32_prefix_length(const char *path, int len)
 	GIT_UNUSED(len);
 #else
 	/*
-	 * Mimic unix behavior where '/.git' returns '/': 'C:/.git'
-	 * will return 'C:/' here
+	 * Mimic unix behavior where '/.git' returns '/': 'C:/.git' will return
+	 * 'C:/' here
 	 */
-	if (dos_drive_prefix_length(path) == len)
-		return len;
+	if (len == 2 && LOOKS_LIKE_DRIVE_PREFIX(path))
+		return 2;
 
 	/*
 	 * Similarly checks if we're dealing with a network computer name
@@ -230,7 +207,7 @@ char *git_path_dirname(const char *path)
 
 	git_path_dirname_r(&buf, path);
 	dirname = git_buf_detach(&buf);
-	git_buf_free(&buf); /* avoid memleak if error occurs */
+	git_buf_dispose(&buf); /* avoid memleak if error occurs */
 
 	return dirname;
 }
@@ -242,7 +219,7 @@ char *git_path_basename(const char *path)
 
 	git_path_basename_r(&buf, path);
 	basename = git_buf_detach(&buf);
-	git_buf_free(&buf); /* avoid memleak if error occurs */
+	git_buf_dispose(&buf); /* avoid memleak if error occurs */
 
 	return basename;
 }
@@ -282,11 +259,11 @@ const char *git_path_topdir(const char *path)
 
 int git_path_root(const char *path)
 {
-	int offset = 0, prefix_len;
+	int offset = 0;
 
 	/* Does the root of the path look like a windows drive ? */
-	if ((prefix_len = dos_drive_prefix_length(path)))
-		offset += prefix_len;
+	if (LOOKS_LIKE_DRIVE_PREFIX(path))
+		offset += 2;
 
 #ifdef GIT_WIN32
 	/* Are we dealing with a windows network path? */
@@ -384,9 +361,9 @@ int git_path_prettify(git_buf *path_out, const char *path, const char *base)
 	}
 
 	if (p_realpath(path, buf) == NULL) {
-		/* giterr_set resets the errno when dealing with a GITERR_OS kind of error */
+		/* git_error_set resets the errno when dealing with a GIT_ERROR_OS kind of error */
 		int error = (errno == ENOENT || errno == ENOTDIR) ? GIT_ENOTFOUND : -1;
-		giterr_set(GITERR_OS, "failed to resolve path '%s'", path);
+		git_error_set(GIT_ERROR_OS, "failed to resolve path '%s'", path);
 
 		git_buf_clear(path_out);
 
@@ -459,7 +436,7 @@ append:
 
 static int error_invalid_local_file_uri(const char *uri)
 {
-	giterr_set(GITERR_CONFIG, "'%s' is not a valid local file URI", uri);
+	git_error_set(GIT_ERROR_CONFIG, "'%s' is not a valid local file URI", uri);
 	return -1;
 }
 
@@ -525,7 +502,7 @@ int git_path_walk_up(
 	if (!scan) {
 		error = cb(data, "");
 		if (error)
-			giterr_set_after_callback(error);
+			git_error_set_after_callback(error);
 		return error;
 	}
 
@@ -538,7 +515,7 @@ int git_path_walk_up(
 		iter.ptr[scan] = oldc;
 
 		if (error) {
-			giterr_set_after_callback(error);
+			git_error_set_after_callback(error);
 			break;
 		}
 
@@ -558,7 +535,7 @@ int git_path_walk_up(
 	if (!error && stop == 0 && iter.ptr[0] != '/') {
 		error = cb(data, "");
 		if (error)
-			giterr_set_after_callback(error);
+			git_error_set_after_callback(error);
 	}
 
 	return error;
@@ -661,11 +638,11 @@ bool git_path_is_empty_dir(const char *path)
 		return false;
 
 	if ((error = git_buf_sets(&dir, path)) != 0)
-		giterr_clear();
+		git_error_clear();
 	else
 		error = git_path_direach(&dir, 0, path_found_entry, NULL);
 
-	git_buf_free(&dir);
+	git_buf_dispose(&dir);
 
 	return !error;
 }
@@ -677,24 +654,24 @@ int git_path_set_error(int errno_value, const char *path, const char *action)
 	switch (errno_value) {
 	case ENOENT:
 	case ENOTDIR:
-		giterr_set(GITERR_OS, "could not find '%s' to %s", path, action);
+		git_error_set(GIT_ERROR_OS, "could not find '%s' to %s", path, action);
 		return GIT_ENOTFOUND;
 
 	case EINVAL:
 	case ENAMETOOLONG:
-		giterr_set(GITERR_OS, "invalid path for filesystem '%s'", path);
+		git_error_set(GIT_ERROR_OS, "invalid path for filesystem '%s'", path);
 		return GIT_EINVALIDSPEC;
 
 	case EEXIST:
-		giterr_set(GITERR_OS, "failed %s - '%s' already exists", action, path);
+		git_error_set(GIT_ERROR_OS, "failed %s - '%s' already exists", action, path);
 		return GIT_EEXISTS;
 
 	case EACCES:
-		giterr_set(GITERR_OS, "failed %s - '%s' is locked", action, path);
+		git_error_set(GIT_ERROR_OS, "failed %s - '%s' is locked", action, path);
 		return GIT_ELOCKED;
 
 	default:
-		giterr_set(GITERR_OS, "could not %s '%s'", action, path);
+		git_error_set(GIT_ERROR_OS, "could not %s '%s'", action, path);
 		return -1;
 	}
 }
@@ -774,7 +751,7 @@ int git_path_resolve_relative(git_buf *path, size_t ceiling)
 	char *base, *to, *from, *next;
 	size_t len;
 
-	GITERR_CHECK_ALLOC_BUF(path);
+	GIT_ERROR_CHECK_ALLOC_BUF(path);
 
 	if (ceiling > path->size)
 		ceiling = path->size;
@@ -803,7 +780,7 @@ int git_path_resolve_relative(git_buf *path, size_t ceiling)
 		else if (len == 2 && from[0] == '.' && from[1] == '.') {
 			/* error out if trying to up one from a hard base */
 			if (to == base && ceiling != 0) {
-				giterr_set(GITERR_INVALID,
+				git_error_set(GIT_ERROR_INVALID,
 					"cannot strip root component off url");
 				return -1;
 			}
@@ -910,7 +887,7 @@ int git_path_make_relative(git_buf *path, const char *parent)
 	/* need at least 1 common path segment */
 	if ((p_dirsep == path->ptr || q_dirsep == parent) &&
 		(*p_dirsep != '/' || *q_dirsep != '/')) {
-		giterr_set(GITERR_INVALID,
+		git_error_set(GIT_ERROR_INVALID,
 			"%s is not a parent of %s", parent, path->ptr);
 		return GIT_ENOTFOUND;
 	}
@@ -934,10 +911,10 @@ int git_path_make_relative(git_buf *path, const char *parent)
 	for (; (q = strchr(q, '/')) && *(q + 1); q++)
 		depth++;
 
-	GITERR_CHECK_ALLOC_MULTIPLY(&newlen, depth, 3);
-	GITERR_CHECK_ALLOC_ADD(&newlen, newlen, plen);
+	GIT_ERROR_CHECK_ALLOC_MULTIPLY(&newlen, depth, 3);
+	GIT_ERROR_CHECK_ALLOC_ADD(&newlen, newlen, plen);
 
-	GITERR_CHECK_ALLOC_ADD(&alloclen, newlen, 1);
+	GIT_ERROR_CHECK_ALLOC_ADD(&alloclen, newlen, 1);
 
 	/* save the offset as we might realllocate the pointer */
 	offset = p - path->ptr;
@@ -979,7 +956,7 @@ void git_path_iconv_clear(git_path_iconv_t *ic)
 	if (ic) {
 		if (ic->map != (iconv_t)-1)
 			iconv_close(ic->map);
-		git_buf_free(&ic->buf);
+		git_buf_dispose(&ic->buf);
 	}
 }
 
@@ -996,7 +973,7 @@ int git_path_iconv(git_path_iconv_t *ic, const char **in, size_t *inlen)
 	git_buf_clear(&ic->buf);
 
 	while (1) {
-		GITERR_CHECK_ALLOC_ADD(&alloclen, wantlen, 1);
+		GIT_ERROR_CHECK_ALLOC_ADD(&alloclen, wantlen, 1);
 		if (git_buf_grow(&ic->buf, alloclen) < 0)
 			return -1;
 
@@ -1033,7 +1010,7 @@ int git_path_iconv(git_path_iconv_t *ic, const char **in, size_t *inlen)
 	return 0;
 
 fail:
-	giterr_set(GITERR_OS, "unable to convert unicode path data");
+	git_error_set(GIT_ERROR_OS, "unable to convert unicode path data");
 	return -1;
 }
 
@@ -1083,7 +1060,7 @@ bool git_path_does_fs_decompose_unicode(const char *root)
 	(void)p_unlink(path.ptr);
 
 done:
-	git_buf_free(&path);
+	git_buf_dispose(&path);
 	return found_decomposed;
 }
 
@@ -1126,7 +1103,7 @@ int git_path_direach(
 	wd_len = git_buf_len(path);
 
 	if ((dir = opendir(path->ptr)) == NULL) {
-		giterr_set(GITERR_OS, "failed to open directory '%s'", path->ptr);
+		git_error_set(GIT_ERROR_OS, "failed to open directory '%s'", path->ptr);
 		if (errno == ENOENT)
 			return GIT_ENOTFOUND;
 
@@ -1153,15 +1130,15 @@ int git_path_direach(
 		if ((error = git_buf_put(path, de_path, de_len)) < 0)
 			break;
 
-		giterr_clear();
+		git_error_clear();
 		error = fn(arg, path);
 
 		git_buf_truncate(path, wd_len); /* restore path */
 
 		/* Only set our own error if the callback did not set one already */
 		if (error != 0) {
-			if (!giterr_last())
-				giterr_set_after_callback(error);
+			if (!git_error_last())
+				git_error_set_after_callback(error);
 
 			break;
 		}
@@ -1207,13 +1184,13 @@ int git_path_diriter_init(
 	git_path_trim_slashes(&diriter->path_utf8);
 
 	if (diriter->path_utf8.size == 0) {
-		giterr_set(GITERR_FILESYSTEM, "could not open directory '%s'", path);
+		git_error_set(GIT_ERROR_FILESYSTEM, "could not open directory '%s'", path);
 		return -1;
 	}
 
 	if ((diriter->parent_len = git_win32_path_from_utf8(diriter->path, diriter->path_utf8.ptr)) < 0 ||
 			!git_win32__findfirstfile_filter(path_filter, diriter->path_utf8.ptr)) {
-		giterr_set(GITERR_OS, "could not parse the directory path '%s'", path);
+		git_error_set(GIT_ERROR_OS, "could not parse the directory path '%s'", path);
 		return -1;
 	}
 
@@ -1226,7 +1203,7 @@ int git_path_diriter_init(
 		is_win7_or_later ? FIND_FIRST_EX_LARGE_FETCH : 0);
 
 	if (diriter->handle == INVALID_HANDLE_VALUE) {
-		giterr_set(GITERR_OS, "could not open directory '%s'", path);
+		git_error_set(GIT_ERROR_OS, "could not open directory '%s'", path);
 		return -1;
 	}
 
@@ -1246,7 +1223,7 @@ static int diriter_update_paths(git_path_diriter *diriter)
 		return -1;
 
 	if (path_len > GIT_WIN_PATH_UTF16) {
-		giterr_set(GITERR_FILESYSTEM,
+		git_error_set(GIT_ERROR_FILESYSTEM,
 			"invalid path '%.*ls\\%ls' (path too long)",
 			diriter->parent_len, diriter->path, diriter->current.cFileName);
 		return -1;
@@ -1331,7 +1308,7 @@ void git_path_diriter_free(git_path_diriter *diriter)
 	if (diriter == NULL)
 		return;
 
-	git_buf_free(&diriter->path_utf8);
+	git_buf_dispose(&diriter->path_utf8);
 
 	if (diriter->handle != INVALID_HANDLE_VALUE) {
 		FindClose(diriter->handle);
@@ -1356,14 +1333,14 @@ int git_path_diriter_init(
 	git_path_trim_slashes(&diriter->path);
 
 	if (diriter->path.size == 0) {
-		giterr_set(GITERR_FILESYSTEM, "could not open directory '%s'", path);
+		git_error_set(GIT_ERROR_FILESYSTEM, "could not open directory '%s'", path);
 		return -1;
 	}
 
 	if ((diriter->dir = opendir(diriter->path.ptr)) == NULL) {
-		git_buf_free(&diriter->path);
+		git_buf_dispose(&diriter->path);
 
-		giterr_set(GITERR_OS, "failed to open directory '%s'", path);
+		git_error_set(GIT_ERROR_OS, "failed to open directory '%s'", path);
 		return -1;
 	}
 
@@ -1395,7 +1372,7 @@ int git_path_diriter_next(git_path_diriter *diriter)
 			if (!errno)
 				return GIT_ITEROVER;
 
-			giterr_set(GITERR_OS,
+			git_error_set(GIT_ERROR_OS,
 				"could not read directory '%s'", diriter->path.ptr);
 			return -1;
 		}
@@ -1471,7 +1448,7 @@ void git_path_diriter_free(git_path_diriter *diriter)
 	git_path_iconv_clear(&diriter->ic);
 #endif
 
-	git_buf_free(&diriter->path);
+	git_buf_dispose(&diriter->path);
 }
 
 #endif
@@ -1500,7 +1477,7 @@ int git_path_dirload(
 		assert(name_len > prefix_len);
 
 		dup = git__strndup(name + prefix_len, name_len - prefix_len);
-		GITERR_CHECK_ALLOC(dup);
+		GIT_ERROR_CHECK_ALLOC(dup);
 
 		if ((error = git_vector_insert(contents, dup)) < 0)
 			break;
@@ -1631,12 +1608,8 @@ GIT_INLINE(bool) verify_dotgit_ntfs(git_repository *repo, const char *path, size
 	if (!start)
 		return true;
 
-	/*
-	 * Reject paths that start with Windows-style directory separators
-	 * (".git\") or NTFS alternate streams (".git:") and could be used
-	 * to write to the ".git" directory on Windows platforms.
-	 */
-	if (path[start] == '\\' || path[start] == ':')
+	/* Reject paths like ".git\" */
+	if (path[start] == '\\')
 		return false;
 
 	/* Reject paths like '.git ' or '.git.' */
@@ -1648,21 +1621,12 @@ GIT_INLINE(bool) verify_dotgit_ntfs(git_repository *repo, const char *path, size
 	return false;
 }
 
-/*
- * Windows paths that end with spaces and/or dots are elided to the
- * path without them for backward compatibility.  That is to say
- * that opening file "foo ", "foo." or even "foo . . ." will all
- * map to a filename of "foo".  This function identifies spaces and
- * dots at the end of a filename, whether the proper end of the
- * filename (end of string) or a colon (which would indicate a
- * Windows alternate data stream.)
- */
-GIT_INLINE(bool) ntfs_end_of_filename(const char *path)
+GIT_INLINE(bool) only_spaces_and_dots(const char *path)
 {
 	const char *c = path;
 
 	for (;; c++) {
-		if (*c == '\0' || *c == ':')
+		if (*c == '\0')
 			return true;
 		if (*c != ' ' && *c != '.')
 			return false;
@@ -1677,13 +1641,13 @@ GIT_INLINE(bool) verify_dotgit_ntfs_generic(const char *name, size_t len, const
 
 	if (name[0] == '.' && len >= dotgit_len &&
 	    !strncasecmp(name + 1, dotgit_name, dotgit_len)) {
-		return !ntfs_end_of_filename(name + dotgit_len + 1);
+		return !only_spaces_and_dots(name + dotgit_len + 1);
 	}
 
 	/* Detect the basic NTFS shortname with the first six chars */
 	if (!strncasecmp(name, dotgit_name, 6) && name[6] == '~' &&
 	    name[7] >= '1' && name[7] <= '4')
-		return !ntfs_end_of_filename(name + 8);
+		return !only_spaces_and_dots(name + 8);
 
 	/* Catch fallback names */
 	for (i = 0, saw_tilde = 0; i < 8; i++) {
@@ -1698,14 +1662,14 @@ GIT_INLINE(bool) verify_dotgit_ntfs_generic(const char *name, size_t len, const
 			saw_tilde = 1;
 		} else if (i >= 6) {
 			return true;
-		} else if (name[i] < 0) {
+		} else if ((unsigned char)name[i] > 127) {
 			return true;
 		} else if (git__tolower(name[i]) != shortname_pfix[i]) {
 			return true;
 		}
 	}
 
-	return !ntfs_end_of_filename(name + i);
+	return !only_spaces_and_dots(name + i);
 }
 
 GIT_INLINE(bool) verify_char(unsigned char c, unsigned int flags)
@@ -1802,14 +1766,14 @@ static bool verify_component(
 	if (flags & GIT_PATH_REJECT_DOT_GIT_HFS) {
 		if (!verify_dotgit_hfs(component, len))
 			return false;
-		if (S_ISLNK(mode) && git_path_is_hfs_dotgit_modules(component, len))
+		if (S_ISLNK(mode) && git_path_is_gitfile(component, len, GIT_PATH_GITFILE_GITMODULES, GIT_PATH_FS_HFS))
 			return false;
 	}
 
 	if (flags & GIT_PATH_REJECT_DOT_GIT_NTFS) {
 		if (!verify_dotgit_ntfs(repo, component, len))
 			return false;
-		if (S_ISLNK(mode) && git_path_is_ntfs_dotgit_modules(component, len))
+		if (S_ISLNK(mode) && git_path_is_gitfile(component, len, GIT_PATH_GITFILE_GITMODULES, GIT_PATH_FS_NTFS))
 			return false;
 	}
 
@@ -1839,7 +1803,7 @@ GIT_INLINE(unsigned int) dotgit_flags(
 	git_repository *repo,
 	unsigned int flags)
 {
-	int protectHFS = 0, protectNTFS = 1;
+	int protectHFS = 0, protectNTFS = 0;
 	int error = 0;
 
 	flags |= GIT_PATH_REJECT_DOT_GIT_LITERAL;
@@ -1848,12 +1812,16 @@ GIT_INLINE(unsigned int) dotgit_flags(
 	protectHFS = 1;
 #endif
 
+#ifdef GIT_WIN32
+	protectNTFS = 1;
+#endif
+
 	if (repo && !protectHFS)
 		error = git_repository__cvar(&protectHFS, repo, GIT_CVAR_PROTECTHFS);
 	if (!error && protectHFS)
 		flags |= GIT_PATH_REJECT_DOT_GIT_HFS;
 
-	if (repo)
+	if (repo && !protectNTFS)
 		error = git_repository__cvar(&protectNTFS, repo, GIT_CVAR_PROTECTNTFS);
 	if (!error && protectNTFS)
 		flags |= GIT_PATH_REJECT_DOT_GIT_NTFS;
@@ -1904,140 +1872,40 @@ int git_path_normalize_slashes(git_buf *out, const char *path)
 	return 0;
 }
 
-static int verify_dotgit_generic(const char *name, size_t len, const char *dotgit_name, size_t dotgit_len, const char *shortname_pfix)
-{
-	if (!verify_dotgit_ntfs_generic(name, len, dotgit_name, dotgit_len, shortname_pfix))
-		return false;
-
-	return verify_dotgit_hfs_generic(name, len, dotgit_name, dotgit_len);
-}
-
-int git_path_is_ntfs_dotgit_modules(const char *name, size_t len)
-{
-	return !verify_dotgit_ntfs_generic(name, len, "gitmodules", CONST_STRLEN("gitmodules"), "gi7eba");
-}
-
-int git_path_is_hfs_dotgit_modules(const char *name, size_t len)
-{
-	return !verify_dotgit_hfs_generic(name, len, "gitmodules", CONST_STRLEN("gitmodules"));
-}
+static const struct {
+	const char *file;
+	const char *hash;
+	size_t filelen;
+} gitfiles[] = {
+	{ "gitignore", "gi250a", CONST_STRLEN("gitignore") },
+	{ "gitmodules", "gi7eba", CONST_STRLEN("gitmodules") },
+	{ "gitattributes", "gi7d29", CONST_STRLEN("gitattributes") }
+};
 
-int git_path_is_dotgit_modules(const char *name, size_t len)
+extern int git_path_is_gitfile(const char *path, size_t pathlen, git_path_gitfile gitfile, git_path_fs fs)
 {
-	if (git_path_is_hfs_dotgit_modules(name, len))
-		return 1;
+	const char *file, *hash;
+	size_t filelen;
 
-	return git_path_is_ntfs_dotgit_modules(name, len);
-}
-
-int git_path_is_ntfs_dotgit_ignore(const char *name, size_t len)
-{
-	return !verify_dotgit_ntfs_generic(name, len, "gitignore", CONST_STRLEN("gitignore"), "gi250a");
-}
-
-int git_path_is_hfs_dotgit_ignore(const char *name, size_t len)
-{
-	return !verify_dotgit_hfs_generic(name, len, "gitignore", CONST_STRLEN("gitignore"));
-}
-
-int git_path_is_dotgit_ignore(const char *name, size_t len)
-{
-	if (git_path_is_hfs_dotgit_ignore(name, len))
-		return 1;
-
-	return git_path_is_ntfs_dotgit_ignore(name, len);
-}
-
-int git_path_is_hfs_dotgit_attributes(const char *name, size_t len)
-{
-	return !verify_dotgit_hfs_generic(name, len, "gitattributes", CONST_STRLEN("gitattributes"));
-}
-
-int git_path_is_ntfs_dotgit_attributes(const char *name, size_t len)
-{
-	return !verify_dotgit_ntfs_generic(name, len, "gitattributes", CONST_STRLEN("gitattributes"), "gi7d29");
-}
-
-int git_path_is_dotgit_attributes(const char *name, size_t len)
-{
-	if (git_path_is_hfs_dotgit_attributes(name, len))
-		return 1;
-
-	return git_path_is_ntfs_dotgit_attributes(name, len);
-}
-
-int git_path_validate_system_file_ownership(const char *path)
-{
-#ifndef GIT_WIN32
-	GIT_UNUSED(path);
-	return GIT_OK;
-#else
-	git_win32_path buf;
-	PSID owner_sid;
-	PSECURITY_DESCRIPTOR descriptor = NULL;
-	HANDLE token;
-	TOKEN_USER *info = NULL;
-	DWORD err, len;
-	int ret;
-
-	if (git_win32_path_from_utf8(buf, path) < 0)
+	if (!(gitfile >= GIT_PATH_GITFILE_GITIGNORE && gitfile < ARRAY_SIZE(gitfiles))) {
+		git_error_set(GIT_ERROR_OS, "invalid gitfile for path validation");
 		return -1;
-
-	err = GetNamedSecurityInfoW(buf, SE_FILE_OBJECT,
-				    OWNER_SECURITY_INFORMATION |
-					    DACL_SECURITY_INFORMATION,
-				    &owner_sid, NULL, NULL, NULL, &descriptor);
-
-	if (err == ERROR_FILE_NOT_FOUND || err == ERROR_PATH_NOT_FOUND) {
-		ret = GIT_ENOTFOUND;
-		goto cleanup;
-	}
-
-	if (err != ERROR_SUCCESS) {
-		giterr_set(GITERR_OS, "failed to get security information");
-		ret = GIT_ERROR;
-		goto cleanup;
-	}
-
-	if (!IsValidSid(owner_sid)) {
-		giterr_set(GITERR_INVALID, "programdata configuration file owner is unknown");
-		ret = GIT_ERROR;
-		goto cleanup;
-	}
-
-	if (IsWellKnownSid(owner_sid, WinBuiltinAdministratorsSid) ||
-	    IsWellKnownSid(owner_sid, WinLocalSystemSid)) {
-		ret = GIT_OK;
-		goto cleanup;
-	}
-
-	/* Obtain current user's SID */
-	if (OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &token) &&
-	    !GetTokenInformation(token, TokenUser, NULL, 0, &len)) {
-		info = git__malloc(len);
-		GITERR_CHECK_ALLOC(info);
-		if (!GetTokenInformation(token, TokenUser, info, len, &len)) {
-			git__free(info);
-			info = NULL;
-		}
 	}
 
-	/*
-	 * If the file is owned by the same account that is running the current
-	 * process, it's okay to read from that file.
-	 */
-	if (info && EqualSid(owner_sid, info->User.Sid))
-		ret = GIT_OK;
-	else {
-		giterr_set(GITERR_INVALID, "programdata configuration file owner is not valid");
-		ret = GIT_ERROR;
+	file = gitfiles[gitfile].file;
+	filelen = gitfiles[gitfile].filelen;
+	hash = gitfiles[gitfile].hash;
+
+	switch (fs) {
+	case GIT_PATH_FS_GENERIC:
+		return !verify_dotgit_ntfs_generic(path, pathlen, file, filelen, hash) ||
+		       !verify_dotgit_hfs_generic(path, pathlen, file, filelen);
+	case GIT_PATH_FS_NTFS:
+		return !verify_dotgit_ntfs_generic(path, pathlen, file, filelen, hash);
+	case GIT_PATH_FS_HFS:
+		return !verify_dotgit_hfs_generic(path, pathlen, file, filelen);
+	default:
+		git_error_set(GIT_ERROR_OS, "invalid filesystem for path validation");
+		return -1;
 	}
-	free(info);
-
-cleanup:
-	if (descriptor)
-		LocalFree(descriptor);
-
-	return ret;
-#endif
 }