rugged 1.7.2 → 1.9.0

data/vendor/libgit2/src/libgit2/transports/ssh_libssh2.h

@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+#ifndef INCLUDE_transports_libssh2_h__
+#define INCLUDE_transports_libssh2_h__
+
+#include "common.h"
+
+#include "git2.h"
+#include "git2/transport.h"
+#include "git2/sys/transport.h"
+
+int git_transport_ssh_libssh2_global_init(void);
+
+int git_smart_subtransport_ssh_libssh2(
+	git_smart_subtransport **out,
+	git_transport *owner,
+	void *param);
+
+int git_smart_subtransport_ssh_libssh2_set_paths(
+	git_smart_subtransport *subtransport,
+	const char *cmd_uploadpack,
+	const char *cmd_receivepack);
+
+#endif

data/vendor/libgit2/src/libgit2/transports/winhttp.c

@@ -293,7 +293,7 @@ static int certificate_check(winhttp_stream *s, int valid)
 
 	/* If there is no override, we should fail if WinHTTP doesn't think it's fine */
 	if (t->owner->connect_opts.callbacks.certificate_check == NULL && !valid) {
-		if (!git_error_last())
+		if (git_error_last()->klass == GIT_ERROR_NONE)
 			git_error_set(GIT_ERROR_HTTP, "unknown certificate check failure");
 
 		return GIT_ECERTIFICATE;
@@ -317,7 +317,7 @@ static int certificate_check(winhttp_stream *s, int valid)
 	if (error == GIT_PASSTHROUGH)
 		error = valid ? 0 : GIT_ECERTIFICATE;
 
-	if (error < 0 && !git_error_last())
+	if (error < 0 && git_error_last()->klass == GIT_ERROR_NONE)
 		git_error_set(GIT_ERROR_HTTP, "user cancelled certificate check");
 
 	return error;
@@ -436,7 +436,7 @@ static int winhttp_stream_connect(winhttp_stream *s)
 		GIT_ERROR_CHECK_ALLOC(proxy_url);
 	}
 
-	if (proxy_url) {
+	if (proxy_url && *proxy_url) {
 		git_str processed_url = GIT_STR_INIT;
 		WINHTTP_PROXY_INFO proxy_info;
 		wchar_t *proxy_wide;
@@ -746,6 +746,33 @@ static void CALLBACK winhttp_status(
 	}
 }
 
+static int user_agent(bool *exists, git_str *out)
+{
+	const char *product = git_settings__user_agent_product();
+	const char *comment = git_settings__user_agent();
+
+	GIT_ASSERT(product && comment);
+
+	if (!*product) {
+		*exists = false;
+		return 0;
+	}
+
+	git_str_puts(out, product);
+
+	if (*comment) {
+		git_str_puts(out, " (");
+		git_str_puts(out, comment);
+		git_str_puts(out, ")");
+	}
+
+	if (git_str_oom(out))
+		return -1;
+
+	*exists = true;
+	return 0;
+}
+
 static int winhttp_connect(
 	winhttp_subtransport *t)
 {
@@ -757,6 +784,7 @@ static int winhttp_connect(
 	int error = -1;
 	int default_timeout = TIMEOUT_INFINITE;
 	int default_connect_timeout = DEFAULT_CONNECT_TIMEOUT;
+	bool has_ua = true;
 	DWORD protocols =
 		WINHTTP_FLAG_SECURE_PROTOCOL_TLS1 |
 		WINHTTP_FLAG_SECURE_PROTOCOL_TLS1_1 |
@@ -787,11 +815,11 @@ static int winhttp_connect(
 		goto on_error;
 	}
 
-
-	if (git_http__user_agent(&ua) < 0)
+	if (user_agent(&has_ua, &ua) < 0)
 		goto on_error;
 
-	if (git_utf8_to_16_alloc(&wide_ua, git_str_cstr(&ua)) < 0) {
+	if (has_ua &&
+	    git_utf8_to_16_alloc(&wide_ua, git_str_cstr(&ua)) < 0) {
 		git_error_set(GIT_ERROR_OS, "unable to convert host to wide characters");
 		goto on_error;
 	}
@@ -933,7 +961,7 @@ static int send_request(winhttp_stream *s, size_t len, bool chunked)
 			(!request_failed && s->status_sending_request_reached)) {
 			git_error_clear();
 			if ((error = certificate_check(s, cert_valid)) < 0) {
-				if (!git_error_last())
+				if (git_error_last()->klass == GIT_ERROR_NONE)
 					git_error_set(GIT_ERROR_OS, "user cancelled certificate check");
 
 				return error;

data/vendor/libgit2/src/libgit2/tree.c

@@ -21,6 +21,8 @@
 #define TREE_ENTRY_CHECK_NAMELEN(n) \
 	if (n > UINT16_MAX) { git_error_set(GIT_ERROR_INVALID, "tree entry path too long"); }
 
+GIT_HASHMAP_STR_FUNCTIONS(git_treebuilder_entrymap, GIT_HASHMAP_INLINE, git_tree_entry *);
+
 static bool valid_filemode(const int filemode)
 {
 	return (filemode == GIT_FILEMODE_TREE
@@ -347,7 +349,7 @@ size_t git_treebuilder_entrycount(git_treebuilder *bld)
 {
 	GIT_ASSERT_ARG_WITH_RETVAL(bld, 0);
 
-	return git_strmap_size(bld->map);
+	return git_treebuilder_entrymap_size(&bld->map);
 }
 
 GIT_INLINE(void) set_error(const char *str, const char *path)
@@ -381,7 +383,7 @@ static int parse_mode(uint16_t *mode_out, const char *buffer, size_t buffer_len,
 	if ((error = git__strntol32(&mode, buffer, buffer_len, buffer_out, 8)) < 0)
 		return error;
 
-	if (mode < 0 || mode > UINT16_MAX)
+	if (mode < 0 || (uint32_t)mode > UINT16_MAX)
 		return -1;
 
 	*mode_out = mode;
@@ -512,10 +514,12 @@ static int git_treebuilder__write_with_buffer(
 	git_tree_entry *entry;
 	git_vector entries = GIT_VECTOR_INIT;
 	size_t oid_size = git_oid_size(bld->repo->oid_type);
+	git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
 
 	git_str_clear(buf);
 
-	entrycount = git_strmap_size(bld->map);
+	entrycount = git_treebuilder_entrymap_size(&bld->map);
+
 	if ((error = git_vector_init(&entries, entrycount, entry_sort_cmp)) < 0)
 		goto out;
 
@@ -523,10 +527,10 @@ static int git_treebuilder__write_with_buffer(
 	    (error = git_str_grow(buf, entrycount * 72)) < 0)
 		goto out;
 
-	git_strmap_foreach_value(bld->map, entry, {
+	while (git_treebuilder_entrymap_iterate(&iter, NULL, &entry, &bld->map) == 0) {
 		if ((error = git_vector_insert(&entries, entry)) < 0)
 			goto out;
-	});
+	}
 
 	git_vector_sort(&entries);
 
@@ -547,7 +551,7 @@ static int git_treebuilder__write_with_buffer(
 		error = git_odb_write(oid, odb, buf->ptr, buf->size, GIT_OBJECT_TREE);
 
 out:
-	git_vector_free(&entries);
+	git_vector_dispose(&entries);
 
 	return error;
 }
@@ -570,7 +574,7 @@ static int append_entry(
 
 	entry->attr = (uint16_t)filemode;
 
-	if ((error = git_strmap_set(bld->map, entry->filename, entry)) < 0) {
+	if ((error = git_treebuilder_entrymap_put(&bld->map, entry->filename, entry)) < 0) {
 		git_tree_entry_free(entry);
 		git_error_set(GIT_ERROR_TREE, "failed to append entry %s to the tree builder", filename);
 		return -1;
@@ -753,11 +757,6 @@ int git_treebuilder_new(
 
 	bld->repo = repo;
 
-	if (git_strmap_new(&bld->map) < 0) {
-		git__free(bld);
-		return -1;
-	}
-
 	if (source != NULL) {
 		git_tree_entry *entry_src;
 
@@ -796,13 +795,13 @@ int git_treebuilder_insert(
 	if ((error = check_entry(bld->repo, filename, id, filemode)) < 0)
 		return error;
 
-	if ((entry = git_strmap_get(bld->map, filename)) != NULL) {
+	if (git_treebuilder_entrymap_get(&entry, &bld->map, filename) == 0) {
 		git_oid_cpy(&entry->oid, id);
 	} else {
 		entry = alloc_entry(filename, strlen(filename), id);
 		GIT_ERROR_CHECK_ALLOC(entry);
 
-		if ((error = git_strmap_set(bld->map, entry->filename, entry)) < 0) {
+		if (git_treebuilder_entrymap_put(&bld->map, entry->filename, entry) < 0) {
 			git_tree_entry_free(entry);
 			git_error_set(GIT_ERROR_TREE, "failed to insert %s", filename);
 			return -1;
@@ -819,10 +818,15 @@ int git_treebuilder_insert(
 
 static git_tree_entry *treebuilder_get(git_treebuilder *bld, const char *filename)
 {
+	git_tree_entry *entry;
+
 	GIT_ASSERT_ARG_WITH_RETVAL(bld, NULL);
 	GIT_ASSERT_ARG_WITH_RETVAL(filename, NULL);
 
-	return git_strmap_get(bld->map, filename);
+	if (git_treebuilder_entrymap_get(&entry, &bld->map, filename) != 0)
+		return NULL;
+
+	return entry;
 }
 
 const git_tree_entry *git_treebuilder_get(git_treebuilder *bld, const char *filename)
@@ -837,7 +841,7 @@ int git_treebuilder_remove(git_treebuilder *bld, const char *filename)
 	if (entry == NULL)
 		return tree_error("failed to remove entry: file isn't in the tree", filename);
 
-	git_strmap_delete(bld->map, filename);
+	git_treebuilder_entrymap_remove(&bld->map, filename);
 	git_tree_entry_free(entry);
 
 	return 0;
@@ -858,16 +862,17 @@ int git_treebuilder_filter(
 {
 	const char *filename;
 	git_tree_entry *entry;
+	git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
 
 	GIT_ASSERT_ARG(bld);
 	GIT_ASSERT_ARG(filter);
 
-	git_strmap_foreach(bld->map, filename, entry, {
-			if (filter(entry, payload)) {
-				git_strmap_delete(bld->map, filename);
-				git_tree_entry_free(entry);
-			}
-	});
+	while (git_treebuilder_entrymap_iterate(&iter, &filename, &entry, &bld->map) == 0) {
+		if (filter(entry, payload)) {
+			git_treebuilder_entrymap_remove(&bld->map, filename);
+			git_tree_entry_free(entry);
+		}
+	}
 
 	return 0;
 }
@@ -875,11 +880,14 @@ int git_treebuilder_filter(
 int git_treebuilder_clear(git_treebuilder *bld)
 {
 	git_tree_entry *e;
+	git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
 
 	GIT_ASSERT_ARG(bld);
 
-	git_strmap_foreach_value(bld->map, e, git_tree_entry_free(e));
-	git_strmap_clear(bld->map);
+	while (git_treebuilder_entrymap_iterate(&iter, NULL, &e, &bld->map) == 0)
+		git_tree_entry_free(e);
+
+	git_treebuilder_entrymap_clear(&bld->map);
 
 	return 0;
 }
@@ -891,7 +899,7 @@ void git_treebuilder_free(git_treebuilder *bld)
 
 	git_str_dispose(&bld->write_cache);
 	git_treebuilder_clear(bld);
-	git_strmap_free(bld->map);
+	git_treebuilder_entrymap_dispose(&bld->map);
 	git__free(bld);
 }
 
@@ -1312,7 +1320,7 @@ cleanup:
 
 	git_str_dispose(&component);
 	git_array_clear(stack);
-	git_vector_free(&entries);
+	git_vector_dispose(&entries);
 	return error;
 }
 

data/vendor/libgit2/src/libgit2/tree.h

@@ -13,7 +13,6 @@
 #include "repository.h"
 #include "odb.h"
 #include "vector.h"
-#include "strmap.h"
 #include "pool.h"
 
 struct git_tree_entry {
@@ -29,9 +28,11 @@ struct git_tree {
 	git_array_t(git_tree_entry) entries;
 };
 
+GIT_HASHMAP_STR_STRUCT(git_treebuilder_entrymap, git_tree_entry *);
+
 struct git_treebuilder {
 	git_repository *repo;
-	git_strmap *map;
+	git_treebuilder_entrymap map;
 	git_str write_cache;
 };
 

data/vendor/libgit2/src/libgit2/worktree.c

@@ -335,11 +335,21 @@ int git_worktree_add(git_worktree **out, git_repository *repo,
 			goto out;
 		}
 
-		if (git_branch_is_checked_out(wtopts.ref)) {
-			git_error_set(GIT_ERROR_WORKTREE, "reference is already checked out");
-			err = -1;
+		if ((err = git_reference_dup(&ref, wtopts.ref)) < 0)
 			goto out;
-		}
+	} else if (wtopts.checkout_existing && git_branch_lookup(&ref, repo, name, GIT_BRANCH_LOCAL) == 0) {
+		/* Do nothing */
+	} else if ((err = git_repository_head(&head, repo)) < 0 ||
+		   (err = git_commit_lookup(&commit, repo, &head->target.oid)) < 0 ||
+		   (err = git_branch_create(&ref, repo, name, commit, false)) < 0) {
+			goto out;
+	}
+
+	if (git_branch_is_checked_out(ref)) {
+		git_error_set(GIT_ERROR_WORKTREE, "reference %s is already checked out",
+			      git_reference_name(ref));
+		err = -1;
+		goto out;
 	}
 
 	/* Create gitdir directory ".git/worktrees/<name>" */
@@ -392,19 +402,6 @@ int git_worktree_add(git_worktree **out, git_repository *repo,
 	    || (err = write_wtfile(gitdir.ptr, "gitdir", &buf)) < 0)
 		goto out;
 
-	/* Set up worktree reference */
-	if (wtopts.ref) {
-		if ((err = git_reference_dup(&ref, wtopts.ref)) < 0)
-			goto out;
-	} else {
-		if ((err = git_repository_head(&head, repo)) < 0)
-			goto out;
-		if ((err = git_commit_lookup(&commit, repo, &head->target.oid)) < 0)
-			goto out;
-		if ((err = git_branch_create(&ref, repo, name, commit, false)) < 0)
-			goto out;
-	}
-
 	/* Set worktree's HEAD */
 	if ((err = git_repository_create_head(gitdir.ptr, git_reference_name(ref))) < 0)
 		goto out;

data/vendor/libgit2/src/util/CMakeLists.txt

@@ -1,8 +1,6 @@
 # util: a shared library for common utility functions for libgit2 projects
 
 add_library(util OBJECT)
-set_target_properties(util PROPERTIES C_STANDARD 90)
-set_target_properties(util PROPERTIES C_EXTENSIONS OFF)
 
 configure_file(git2_features.h.in git2_features.h)
 
@@ -36,7 +34,7 @@ if(USE_SHA1 STREQUAL "CollisionDetection")
 	target_compile_definitions(util PRIVATE SHA1DC_NO_STANDARD_INCLUDES=1)
         target_compile_definitions(util PRIVATE SHA1DC_CUSTOM_INCLUDE_SHA1_C=\"git2_util.h\")
         target_compile_definitions(util PRIVATE SHA1DC_CUSTOM_INCLUDE_UBC_CHECK_C=\"git2_util.h\")
-elseif(USE_SHA1 STREQUAL "OpenSSL" OR USE_SHA1 STREQUAL "OpenSSL-Dynamic")
+elseif(USE_SHA1 STREQUAL "OpenSSL" OR USE_SHA1 STREQUAL "OpenSSL-Dynamic" OR USE_SHA1 STREQUAL "OpenSSL-FIPS")
 	add_definitions(-DOPENSSL_API_COMPAT=0x10100000L)
 	file(GLOB UTIL_SRC_SHA1 hash/openssl.*)
 elseif(USE_SHA1 STREQUAL "CommonCrypto")
@@ -51,9 +49,9 @@ endif()
 
 list(SORT UTIL_SRC_SHA1)
 
-if(USE_SHA256 STREQUAL "Builtin")
+if(USE_SHA256 STREQUAL "builtin")
 	file(GLOB UTIL_SRC_SHA256 hash/builtin.* hash/rfc6234/*)
-elseif(USE_SHA256 STREQUAL "OpenSSL" OR USE_SHA256 STREQUAL "OpenSSL-Dynamic")
+elseif(USE_SHA256 STREQUAL "OpenSSL" OR USE_SHA256 STREQUAL "OpenSSL-Dynamic" OR USE_SHA256 STREQUAL "OpenSSL-FIPS")
 	add_definitions(-DOPENSSL_API_COMPAT=0x10100000L)
 	file(GLOB UTIL_SRC_SHA256 hash/openssl.*)
 elseif(USE_SHA256 STREQUAL "CommonCrypto")
@@ -63,7 +61,7 @@ elseif(USE_SHA256 STREQUAL "mbedTLS")
 elseif(USE_SHA256 STREQUAL "Win32")
 	file(GLOB UTIL_SRC_SHA256 hash/win32.*)
 else()
-	message(FATAL_ERROR "Asked for unknown SHA256 backend: ${USE_SHA256}")
+	message(FATAL_ERROR "asked for unknown SHA256 backend: ${USE_SHA256}")
 endif()
 
 list(SORT UTIL_SRC_SHA256)

data/vendor/libgit2/src/util/alloc.c

@@ -8,8 +8,9 @@
 #include "alloc.h"
 #include "runtime.h"
 
-#include "allocators/failalloc.h"
 #include "allocators/stdalloc.h"
+#include "allocators/debugalloc.h"
+#include "allocators/failalloc.h"
 #include "allocators/win32_leakcheck.h"
 
 /* Fail any allocation until git_libgit2_init is called. */
@@ -88,6 +89,8 @@ static int setup_default_allocator(void)
 {
 #if defined(GIT_WIN32_LEAKCHECK)
 	return git_win32_leakcheck_init_allocator(&git__allocator);
+#elif defined(GIT_DEBUG_STRICT_ALLOC)
+	return git_debugalloc_init_allocator(&git__allocator);
 #else
 	return git_stdalloc_init_allocator(&git__allocator);
 #endif

data/vendor/libgit2/src/util/allocators/debugalloc.c

@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+
+#include "debugalloc.h"
+
+static void *debugalloc__malloc(size_t len, const char *file, int line)
+{
+	unsigned char *ptr;
+	size_t total = len + sizeof(size_t);
+
+	GIT_UNUSED(file);
+	GIT_UNUSED(line);
+
+	if (!len || (ptr = malloc(total)) == NULL)
+		return NULL;
+
+	memcpy(ptr, &len, sizeof(size_t));
+	return ptr + sizeof(size_t);
+}
+
+static void *debugalloc__realloc(void *_ptr, size_t len, const char *file, int line)
+{
+	unsigned char *ptr = _ptr, *newptr;
+	size_t original_len;
+	size_t total = len + sizeof(size_t);
+
+	GIT_UNUSED(file);
+	GIT_UNUSED(line);
+
+	if (!len && !ptr)
+		return NULL;
+
+	if (!len) {
+		free(ptr - sizeof(size_t));
+		return NULL;
+	}
+
+	if ((newptr = malloc(total)) == NULL)
+		return NULL;
+
+	if (ptr) {
+		memcpy(&original_len, ptr - sizeof(size_t), sizeof(size_t));
+		memcpy(newptr + sizeof(size_t), ptr, min(len, original_len));
+
+		memset(ptr - sizeof(size_t), 0xfd, original_len + sizeof(size_t));
+		free(ptr - sizeof(size_t));
+	}
+
+	memcpy(newptr, &len, sizeof(size_t));
+	return newptr + sizeof(size_t);
+}
+
+static void debugalloc__free(void *_ptr)
+{
+	unsigned char *ptr = _ptr;
+
+	if (!ptr)
+		return;
+
+	free(ptr - sizeof(size_t));
+}
+
+int git_debugalloc_init_allocator(git_allocator *allocator)
+{
+	allocator->gmalloc = debugalloc__malloc;
+	allocator->grealloc = debugalloc__realloc;
+	allocator->gfree = debugalloc__free;
+	return 0;
+}

data/vendor/libgit2/src/{cli/cli.h → util/allocators/debugalloc.h}

@@ -5,16 +5,13 @@
  * a Linking Exception. For full terms see the included COPYING file.
  */
 
-#ifndef CLI_cli_h__
-#define CLI_cli_h__
-
-#define PROGRAM_NAME "git2"
+#ifndef INCLUDE_allocators_debugalloc_h__
+#define INCLUDE_allocators_debugalloc_h__
 
 #include "git2_util.h"
 
-#include "error.h"
-#include "opt.h"
-#include "opt_usage.h"
-#include "sighandler.h"
+#include "alloc.h"
+
+int git_debugalloc_init_allocator(git_allocator *allocator);
 
-#endif /* CLI_cli_h__ */
+#endif

data/vendor/libgit2/src/util/allocators/stdalloc.c

@@ -12,11 +12,6 @@ static void *stdalloc__malloc(size_t len, const char *file, int line)
 	GIT_UNUSED(file);
 	GIT_UNUSED(line);
 
-#ifdef GIT_DEBUG_STRICT_ALLOC
-	if (!len)
-		return NULL;
-#endif
-
 	return malloc(len);
 }
 
@@ -25,11 +20,6 @@ static void *stdalloc__realloc(void *ptr, size_t size, const char *file, int lin
 	GIT_UNUSED(file);
 	GIT_UNUSED(line);
 
-#ifdef GIT_DEBUG_STRICT_ALLOC
-	if (!size)
-		return NULL;
-#endif
-
 	return realloc(ptr, size);
 }
 

data/vendor/libgit2/src/util/array.h

@@ -41,39 +41,40 @@
 
 #define GIT_ERROR_CHECK_ARRAY(a) GIT_ERROR_CHECK_ALLOC((a).ptr)
 
-
-typedef git_array_t(char) git_array_generic_t;
-
-/* use a generic array for growth, return 0 on success */
-GIT_INLINE(int) git_array_grow(void *_a, size_t item_size)
+GIT_INLINE(void *) git_array__alloc(void *arr, size_t *size, size_t *asize, size_t item_size)
 {
-	volatile git_array_generic_t *a = _a;
 	size_t new_size;
-	char *new_array;
+	void *new_array;
+
+	if (*size < *asize)
+		return arr;
 
-	if (a->size < 8) {
+	if (*size < 8) {
 		new_size = 8;
 	} else {
-		if (GIT_MULTIPLY_SIZET_OVERFLOW(&new_size, a->size, 3))
+		if (GIT_MULTIPLY_SIZET_OVERFLOW(&new_size, *asize, 3))
 			goto on_oom;
+
 		new_size /= 2;
 	}
 
-	if ((new_array = git__reallocarray(a->ptr, new_size, item_size)) == NULL)
+	if ((new_array = git__reallocarray(arr, new_size, item_size)) == NULL)
 		goto on_oom;
 
-	a->ptr = new_array;
-	a->asize = new_size;
-	return 0;
+	*asize = new_size;
+
+	return new_array;
 
 on_oom:
-	git_array_clear(*a);
-	return -1;
+	git__free(arr);
+	*size = 0;
+	*asize = 0;
+	return NULL;
 }
 
 #define git_array_alloc(a) \
-	(((a).size < (a).asize || git_array_grow(&(a), sizeof(*(a).ptr)) == 0) ? \
-	&(a).ptr[(a).size++] : (void *)NULL)
+	(((a).size < (a).asize || \
+	 ((a).ptr = git_array__alloc((a).ptr, &(a).size, &(a).asize, sizeof(*(a).ptr))) != NULL) ? &(a).ptr[(a).size++] : (void *)NULL)
 
 #define git_array_last(a) ((a).size ? &(a).ptr[(a).size - 1] : (void *)NULL)
 

data/vendor/libgit2/src/util/cc-compat.h

@@ -44,9 +44,11 @@
 		_unused = (x);                                                 \
 	} while (0)
 # define GIT_UNUSED_ARG __attribute__((unused))
+# define GIT_UNUSED_FUNCTION __attribute__((unused))
 #else
 # define GIT_UNUSED(x) ((void)(x))
 # define GIT_UNUSED_ARG
+# define GIT_UNUSED_FUNCTION
 #endif
 
 /* Define the printf format specifier to use for size_t output */

data/vendor/libgit2/src/util/ctype_compat.h

@@ -0,0 +1,70 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+#ifndef INCLUDE_ctype_compat_h__
+#define INCLUDE_ctype_compat_h__
+
+/*
+ * The Microsoft C runtime (MSVCRT) may take a heavy lock on the
+ * locale in order to figure out how the `ctype` functions work.
+ * This is deeply slow. Provide our own to avoid that.
+ */
+
+#ifdef GIT_WIN32
+
+GIT_INLINE(int) git__tolower(int c)
+{
+	return (c >= 'A' && c <= 'Z') ? (c + 32) : c;
+}
+
+GIT_INLINE(int) git__toupper(int c)
+{
+	return (c >= 'a' && c <= 'z') ? (c - 32) : c;
+}
+
+GIT_INLINE(bool) git__isalpha(int c)
+{
+	return ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z'));
+}
+
+GIT_INLINE(bool) git__isdigit(int c)
+{
+	return (c >= '0' && c <= '9');
+}
+
+GIT_INLINE(bool) git__isalnum(int c)
+{
+	return git__isalpha(c) || git__isdigit(c);
+}
+
+GIT_INLINE(bool) git__isspace(int c)
+{
+	return (c == ' ' || c == '\t' || c == '\n' || c == '\f' || c == '\r' || c == '\v');
+}
+
+GIT_INLINE(bool) git__isxdigit(int c)
+{
+	return ((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'));
+}
+
+GIT_INLINE(bool) git__isprint(int c)
+{
+	return (c >= ' ' && c <= '~');
+}
+
+#else
+# define git__tolower(a) tolower((unsigned char)(a))
+# define git__toupper(a) toupper((unsigned char)(a))
+
+# define git__isalpha(a)  (!!isalpha((unsigned char)(a)))
+# define git__isdigit(a)  (!!isdigit((unsigned char)(a)))
+# define git__isalnum(a)  (!!isalnum((unsigned char)(a)))
+# define git__isspace(a)  (!!isspace((unsigned char)(a)))
+# define git__isxdigit(a) (!!isxdigit((unsigned char)(a)))
+# define git__isprint(a)  (!!isprint((unsigned char)(a)))
+#endif
+
+#endif