rugged 1.5.0.1 → 1.7.1

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

@@ -71,12 +71,16 @@ const git_tree_cache *git_tree_cache_get(const git_tree_cache *tree, const char
 	}
 }
 
-static int read_tree_internal(git_tree_cache **out,
-			      const char **buffer_in, const char *buffer_end,
-			      git_pool *pool)
+static int read_tree_internal(
+	git_tree_cache **out,
+	const char **buffer_in,
+	const char *buffer_end,
+	git_oid_t oid_type,
+	git_pool *pool)
 {
 	git_tree_cache *tree = NULL;
 	const char *name_start, *buffer;
+	size_t oid_size = git_oid_size(oid_type);
 	int count;
 
 	buffer = name_start = *buffer_in;
@@ -87,7 +91,7 @@ static int read_tree_internal(git_tree_cache **out,
 	if (++buffer >= buffer_end)
 		goto corrupted;
 
-	if (git_tree_cache_new(&tree, name_start, pool) < 0)
+	if (git_tree_cache_new(&tree, name_start, oid_type, pool) < 0)
 		return -1;
 
 	/* Blank-terminated ASCII decimal number of entries in this tree */
@@ -108,14 +112,14 @@ static int read_tree_internal(git_tree_cache **out,
 	if (*buffer != '\n' || ++buffer > buffer_end)
 		goto corrupted;
 
-	/* The SHA1 is only there if it's not invalidated */
+	/* The OID is only there if it's not invalidated */
 	if (tree->entry_count >= 0) {
 		/* 160-bit SHA-1 for this tree and it's children */
-		if (buffer + GIT_OID_RAWSZ > buffer_end)
+		if (buffer + oid_size > buffer_end)
 			goto corrupted;
 
-		git_oid_fromraw(&tree->oid, (const unsigned char *)buffer);
-		buffer += GIT_OID_RAWSZ;
+		git_oid__fromraw(&tree->oid, (const unsigned char *)buffer, oid_type);
+		buffer += oid_size;
 	}
 
 	/* Parse children: */
@@ -130,7 +134,7 @@ static int read_tree_internal(git_tree_cache **out,
 		memset(tree->children, 0x0, bufsize);
 
 		for (i = 0; i < tree->children_count; ++i) {
-			if (read_tree_internal(&tree->children[i], &buffer, buffer_end, pool) < 0)
+			if (read_tree_internal(&tree->children[i], &buffer, buffer_end, oid_type, pool) < 0)
 				goto corrupted;
 		}
 	}
@@ -144,11 +148,16 @@ static int read_tree_internal(git_tree_cache **out,
 	return -1;
 }
 
-int git_tree_cache_read(git_tree_cache **tree, const char *buffer, size_t buffer_size, git_pool *pool)
+int git_tree_cache_read(
+	git_tree_cache **tree,
+	const char *buffer,
+	size_t buffer_size,
+	git_oid_t oid_type,
+	git_pool *pool)
 {
 	const char *buffer_end = buffer + buffer_size;
 
-	if (read_tree_internal(tree, &buffer, buffer_end, pool) < 0)
+	if (read_tree_internal(tree, &buffer, buffer_end, oid_type, pool) < 0)
 		return -1;
 
 	if (buffer < buffer_end) {
@@ -201,7 +210,7 @@ static int read_tree_recursive(git_tree_cache *cache, const git_tree *tree, git_
 			continue;
 		}
 
-		if ((error = git_tree_cache_new(&cache->children[j], git_tree_entry_name(entry), pool)) < 0)
+		if ((error = git_tree_cache_new(&cache->children[j], git_tree_entry_name(entry), cache->oid_type, pool)) < 0)
 			return error;
 
 		if ((error = git_tree_lookup(&subtree, repo, git_tree_entry_id(entry))) < 0)
@@ -219,12 +228,12 @@ static int read_tree_recursive(git_tree_cache *cache, const git_tree *tree, git_
 	return 0;
 }
 
-int git_tree_cache_read_tree(git_tree_cache **out, const git_tree *tree, git_pool *pool)
+int git_tree_cache_read_tree(git_tree_cache **out, const git_tree *tree, git_oid_t oid_type, git_pool *pool)
 {
 	int error;
 	git_tree_cache *cache;
 
-	if ((error = git_tree_cache_new(&cache, "", pool)) < 0)
+	if ((error = git_tree_cache_new(&cache, "", oid_type, pool)) < 0)
 		return error;
 
 	if ((error = read_tree_recursive(cache, tree, pool)) < 0)
@@ -234,7 +243,7 @@ int git_tree_cache_read_tree(git_tree_cache **out, const git_tree *tree, git_poo
 	return 0;
 }
 
-int git_tree_cache_new(git_tree_cache **out, const char *name, git_pool *pool)
+int git_tree_cache_new(git_tree_cache **out, const char *name, git_oid_t oid_type, git_pool *pool)
 {
 	size_t name_len, alloc_size;
 	git_tree_cache *tree;
@@ -248,6 +257,7 @@ int git_tree_cache_new(git_tree_cache **out, const char *name, git_pool *pool)
 
 	memset(tree, 0x0, sizeof(git_tree_cache));
 	/* NUL-terminated tree name */
+	tree->oid_type = oid_type;
 	tree->namelen = name_len;
 	memcpy(tree->name, name, name_len);
 	tree->name[name_len] = '\0';
@@ -263,7 +273,7 @@ static void write_tree(git_str *out, git_tree_cache *tree)
 	git_str_printf(out, "%s%c%"PRIdZ" %"PRIuZ"\n", tree->name, 0, tree->entry_count, tree->children_count);
 
 	if (tree->entry_count != -1)
-		git_str_put(out, (char *)&tree->oid.id, GIT_OID_RAWSZ);
+		git_str_put(out, (char *)&tree->oid.id, git_oid_size(tree->oid_type));
 
 	for (i = 0; i < tree->children_count; i++)
 		write_tree(out, tree->children[i]);

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

@@ -18,6 +18,8 @@ typedef struct git_tree_cache {
 	struct git_tree_cache **children;
 	size_t children_count;
 
+	git_oid_t oid_type;
+
 	ssize_t entry_count;
 	git_oid oid;
 	size_t namelen;
@@ -25,14 +27,14 @@ typedef struct git_tree_cache {
 } git_tree_cache;
 
 int git_tree_cache_write(git_str *out, git_tree_cache *tree);
-int git_tree_cache_read(git_tree_cache **tree, const char *buffer, size_t buffer_size, git_pool *pool);
+int git_tree_cache_read(git_tree_cache **tree, const char *buffer, size_t buffer_size, git_oid_t oid_type, git_pool *pool);
 void git_tree_cache_invalidate_path(git_tree_cache *tree, const char *path);
 const git_tree_cache *git_tree_cache_get(const git_tree_cache *tree, const char *path);
-int git_tree_cache_new(git_tree_cache **out, const char *name, git_pool *pool);
+int git_tree_cache_new(git_tree_cache **out, const char *name, git_oid_t oid_type, git_pool *pool);
 /**
  * Read a tree as the root of the tree cache (like for `git read-tree`)
  */
-int git_tree_cache_read_tree(git_tree_cache **out, const git_tree *tree, git_pool *pool);
+int git_tree_cache_read_tree(git_tree_cache **out, const git_tree *tree, git_oid_t oid_type, git_pool *pool);
 void git_tree_cache_free(git_tree_cache *tree);
 
 #endif

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

@@ -85,11 +85,17 @@ static git_tree_entry *alloc_entry(const char *filename, size_t filename_len, co
 	char *filename_ptr;
 	size_t tree_len;
 
+#ifdef GIT_EXPERIMENTAL_SHA256
+	size_t oid_size = git_oid_size(id->type);
+#else
+	size_t oid_size = GIT_OID_SHA1_SIZE;
+#endif
+
 	TREE_ENTRY_CHECK_NAMELEN(filename_len);
 
 	if (GIT_ADD_SIZET_OVERFLOW(&tree_len, sizeof(git_tree_entry), filename_len) ||
 	    GIT_ADD_SIZET_OVERFLOW(&tree_len, tree_len, 1) ||
-	    GIT_ADD_SIZET_OVERFLOW(&tree_len, tree_len, GIT_OID_RAWSZ))
+	    GIT_ADD_SIZET_OVERFLOW(&tree_len, tree_len, oid_size))
 		return NULL;
 
 	entry = git__calloc(1, tree_len);
@@ -383,11 +389,12 @@ static int parse_mode(uint16_t *mode_out, const char *buffer, size_t buffer_len,
 	return 0;
 }
 
-int git_tree__parse_raw(void *_tree, const char *data, size_t size)
+int git_tree__parse_raw(void *_tree, const char *data, size_t size, git_oid_t oid_type)
 {
 	git_tree *tree = _tree;
 	const char *buffer;
 	const char *buffer_end;
+	const long oid_size = (long)git_oid_size(oid_type);
 
 	buffer = data;
 	buffer_end = buffer + size;
@@ -414,35 +421,33 @@ int git_tree__parse_raw(void *_tree, const char *data, size_t size)
 		if ((filename_len = nul - buffer) == 0 || filename_len > UINT16_MAX)
 			return tree_parse_error("failed to parse tree: can't parse filename", NULL);
 
-		if ((buffer_end - (nul + 1)) < GIT_OID_RAWSZ)
+		if ((buffer_end - (nul + 1)) < (long)oid_size)
 			return tree_parse_error("failed to parse tree: can't parse OID", NULL);
 
 		/* Allocate the entry */
-		{
-			entry = git_array_alloc(tree->entries);
-			GIT_ERROR_CHECK_ALLOC(entry);
-
-			entry->attr = attr;
-			entry->filename_len = (uint16_t)filename_len;
-			entry->filename = buffer;
-			git_oid_fromraw(&entry->oid, ((unsigned char *) buffer + filename_len + 1));
-		}
+		entry = git_array_alloc(tree->entries);
+		GIT_ERROR_CHECK_ALLOC(entry);
 
+		entry->attr = attr;
+		entry->filename_len = (uint16_t)filename_len;
+		entry->filename = buffer;
 		buffer += filename_len + 1;
-		buffer += GIT_OID_RAWSZ;
+
+		git_oid__fromraw(&entry->oid, (unsigned char *)buffer, oid_type);
+		buffer += oid_size;
 	}
 
 	return 0;
 }
 
-int git_tree__parse(void *_tree, git_odb_object *odb_obj)
+int git_tree__parse(void *_tree, git_odb_object *odb_obj, git_oid_t oid_type)
 {
 	git_tree *tree = _tree;
 	const char *data = git_odb_object_data(odb_obj);
 	size_t size = git_odb_object_size(odb_obj);
 	int error;
 
-	if ((error = git_tree__parse_raw(tree, data, size)) < 0 ||
+	if ((error = git_tree__parse_raw(tree, data, size, oid_type)) < 0 ||
 	    (error = git_odb_object_dup(&tree->odb_obj, odb_obj)) < 0)
 		return error;
 
@@ -506,6 +511,7 @@ static int git_treebuilder__write_with_buffer(
 	git_odb *odb;
 	git_tree_entry *entry;
 	git_vector entries = GIT_VECTOR_INIT;
+	size_t oid_size = git_oid_size(bld->repo->oid_type);
 
 	git_str_clear(buf);
 
@@ -529,7 +535,7 @@ static int git_treebuilder__write_with_buffer(
 
 		git_str_printf(buf, "%o ", entry->attr);
 		git_str_put(buf, entry->filename, entry->filename_len + 1);
-		git_str_put(buf, (char *)entry->oid.id, GIT_OID_RAWSZ);
+		git_str_put(buf, (char *)entry->oid.id, oid_size);
 
 		if (git_str_oom(buf)) {
 			error = -1;
@@ -725,7 +731,7 @@ int git_tree__write_index(
 		return ret;
 
 	/* Read the tree cache into the index */
-	ret = git_tree_cache_read_tree(&index->tree, tree, &index->tree_pool);
+	ret = git_tree_cache_read_tree(&index->tree, tree, index->oid_type, &index->tree_pool);
 	git_tree_free(tree);
 
 	return ret;

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

@@ -41,8 +41,8 @@ GIT_INLINE(bool) git_tree_entry__is_tree(const struct git_tree_entry *e)
 }
 
 void git_tree__free(void *tree);
-int git_tree__parse(void *tree, git_odb_object *obj);
-int git_tree__parse_raw(void *_tree, const char *data, size_t size);
+int git_tree__parse(void *tree, git_odb_object *obj, git_oid_t oid_type);
+int git_tree__parse_raw(void *_tree, const char *data, size_t size, git_oid_t oid_type);
 
 /**
  * Write a tree to the given repository

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

@@ -187,6 +187,11 @@ int git_worktree_lookup(git_worktree **out, git_repository *repo, const char *na
 	if ((error = git_str_join3(&path, '/', repo->commondir, "worktrees", name)) < 0)
 		goto out;
 
+	if (!git_fs_path_isdir(path.ptr)) {
+		error = GIT_ENOTFOUND;
+		goto out;
+	}
+
 	if ((error = (open_worktree_dir(out, git_repository_workdir(repo), path.ptr, name))) < 0)
 		goto out;
 
@@ -560,6 +565,8 @@ int git_worktree_is_prunable(git_worktree *wt,
 	git_worktree_prune_options *opts)
 {
 	git_worktree_prune_options popts = GIT_WORKTREE_PRUNE_OPTIONS_INIT;
+	git_str path = GIT_STR_INIT;
+	int ret = 0;
 
 	GIT_ERROR_CHECK_VERSION(
 		opts, GIT_WORKTREE_PRUNE_OPTIONS_VERSION,
@@ -570,27 +577,40 @@ int git_worktree_is_prunable(git_worktree *wt,
 
 	if ((popts.flags & GIT_WORKTREE_PRUNE_LOCKED) == 0) {
 		git_str reason = GIT_STR_INIT;
-		int error;
 
-		if ((error = git_worktree__is_locked(&reason, wt)) < 0)
-			return error;
+		if ((ret = git_worktree__is_locked(&reason, wt)) < 0)
+			goto out;
+
+		if (ret) {
+			git_error_set(GIT_ERROR_WORKTREE,
+				"not pruning locked working tree: '%s'",
+				reason.size ?  reason.ptr : "is locked");
 
-		if (error) {
-			if (!reason.size)
-				git_str_attach_notowned(&reason, "no reason given", 15);
-			git_error_set(GIT_ERROR_WORKTREE, "not pruning locked working tree: '%s'", reason.ptr);
 			git_str_dispose(&reason);
-			return 0;
+			ret = 0;
+			goto out;
 		}
 	}
 
 	if ((popts.flags & GIT_WORKTREE_PRUNE_VALID) == 0 &&
 	    git_worktree_validate(wt) == 0) {
 		git_error_set(GIT_ERROR_WORKTREE, "not pruning valid working tree");
-		return 0;
+		goto out;
 	}
 
-	return 1;
+	if ((ret = git_str_printf(&path, "%s/worktrees/%s", wt->commondir_path, wt->name) < 0))
+		goto out;
+
+	if (!git_fs_path_exists(path.ptr)) {
+		git_error_set(GIT_ERROR_WORKTREE, "worktree gitdir ('%s') does not exist", path.ptr);
+		goto out;
+	}
+
+	ret = 1;
+
+out:
+	git_str_dispose(&path);
+	return ret;
 }
 
 int git_worktree_prune(git_worktree *wt,

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

@@ -4,8 +4,11 @@ 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)
+
 set(UTIL_INCLUDES
-	"${PROJECT_BINARY_DIR}/src"
+	"${PROJECT_BINARY_DIR}/src/util"
+	"${PROJECT_BINARY_DIR}/include"
 	"${PROJECT_SOURCE_DIR}/src/util"
 	"${PROJECT_SOURCE_DIR}/include")
 
@@ -34,6 +37,7 @@ if(USE_SHA1 STREQUAL "CollisionDetection")
         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")
+	add_definitions(-DOPENSSL_API_COMPAT=0x10100000L)
 	file(GLOB UTIL_SRC_SHA1 hash/openssl.*)
 elseif(USE_SHA1 STREQUAL "CommonCrypto")
 	file(GLOB UTIL_SRC_SHA1 hash/common_crypto.*)
@@ -50,6 +54,7 @@ list(SORT UTIL_SRC_SHA1)
 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")
+	add_definitions(-DOPENSSL_API_COMPAT=0x10100000L)
 	file(GLOB UTIL_SRC_SHA256 hash/openssl.*)
 elseif(USE_SHA256 STREQUAL "CommonCrypto")
 	file(GLOB UTIL_SRC_SHA256 hash/common_crypto.*)

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

@@ -15,16 +15,75 @@
 /* Fail any allocation until git_libgit2_init is called. */
 git_allocator git__allocator = {
 	git_failalloc_malloc,
-	git_failalloc_calloc,
-	git_failalloc_strdup,
-	git_failalloc_strndup,
-	git_failalloc_substrdup,
 	git_failalloc_realloc,
-	git_failalloc_reallocarray,
-	git_failalloc_mallocarray,
 	git_failalloc_free
 };
 
+void *git__calloc(size_t nelem, size_t elsize)
+{
+	size_t newsize;
+	void *ptr;
+
+	if (GIT_MULTIPLY_SIZET_OVERFLOW(&newsize, nelem, elsize))
+		return NULL;
+
+	if ((ptr = git__malloc(newsize)))
+		memset(ptr, 0, newsize);
+
+	return ptr;
+}
+
+void *git__reallocarray(void *ptr, size_t nelem, size_t elsize)
+{
+	size_t newsize;
+
+	if (GIT_MULTIPLY_SIZET_OVERFLOW(&newsize, nelem, elsize))
+		return NULL;
+
+	return git__realloc(ptr, newsize);
+}
+
+void *git__mallocarray(size_t nelem, size_t elsize)
+{
+	return git__reallocarray(NULL, nelem, elsize);
+}
+
+char *git__strdup(const char *str)
+{
+	size_t len = strlen(str) + 1;
+	void *ptr = git__malloc(len);
+
+	if (ptr)
+		memcpy(ptr, str, len);
+
+	return ptr;
+}
+
+char *git__strndup(const char *str, size_t n)
+{
+	size_t len = p_strnlen(str, n);
+	char *ptr = git__malloc(len + 1);
+
+	if (ptr) {
+		memcpy(ptr, str, len);
+		ptr[len] = '\0';
+	}
+
+	return ptr;
+}
+
+char *git__substrdup(const char *str, size_t n)
+{
+	char *ptr = git__malloc(n + 1);
+
+	if (ptr) {
+		memcpy(ptr, str, n);
+		ptr[n] = '\0';
+	}
+
+	return ptr;
+}
+
 static int setup_default_allocator(void)
 {
 #if defined(GIT_WIN32_LEAKCHECK)

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

@@ -10,17 +10,42 @@
 
 #include "git2/sys/alloc.h"
 
+#include "git2_util.h"
+
 extern git_allocator git__allocator;
 
-#define git__malloc(len)                      git__allocator.gmalloc(len, __FILE__, __LINE__)
-#define git__calloc(nelem, elsize)            git__allocator.gcalloc(nelem, elsize, __FILE__, __LINE__)
-#define git__strdup(str)                      git__allocator.gstrdup(str, __FILE__, __LINE__)
-#define git__strndup(str, n)                  git__allocator.gstrndup(str, n, __FILE__, __LINE__)
-#define git__substrdup(str, n)                git__allocator.gsubstrdup(str, n, __FILE__, __LINE__)
-#define git__realloc(ptr, size)               git__allocator.grealloc(ptr, size, __FILE__, __LINE__)
-#define git__reallocarray(ptr, nelem, elsize) git__allocator.greallocarray(ptr, nelem, elsize, __FILE__, __LINE__)
-#define git__mallocarray(nelem, elsize)       git__allocator.gmallocarray(nelem, elsize, __FILE__, __LINE__)
-#define git__free                             git__allocator.gfree
+GIT_INLINE(void *) git__malloc(size_t len)
+{
+	void *p = git__allocator.gmalloc(len, __FILE__, __LINE__);
+
+	if (!p)
+		git_error_set_oom();
+
+	return p;
+}
+
+GIT_INLINE(void *) git__realloc(void *ptr, size_t size)
+{
+	void *p = git__allocator.grealloc(ptr, size, __FILE__, __LINE__);
+
+	if (!p)
+		git_error_set_oom();
+
+	return p;
+}
+
+GIT_INLINE(void) git__free(void *ptr)
+{
+	git__allocator.gfree(ptr);
+}
+
+extern void *git__calloc(size_t nelem, size_t elsize);
+extern void *git__mallocarray(size_t nelem, size_t elsize);
+extern void *git__reallocarray(void *ptr, size_t nelem, size_t elsize);
+
+extern char *git__strdup(const char *str);
+extern char *git__strndup(const char *str, size_t n);
+extern char *git__substrdup(const char *str, size_t n);
 
 /**
  * This function is being called by our global setup routines to

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

@@ -16,45 +16,6 @@ void *git_failalloc_malloc(size_t len, const char *file, int line)
 	return NULL;
 }
 
-void *git_failalloc_calloc(size_t nelem, size_t elsize, const char *file, int line)
-{
-	GIT_UNUSED(nelem);
-	GIT_UNUSED(elsize);
-	GIT_UNUSED(file);
-	GIT_UNUSED(line);
-
-	return NULL;
-}
-
-char *git_failalloc_strdup(const char *str, const char *file, int line)
-{
-	GIT_UNUSED(str);
-	GIT_UNUSED(file);
-	GIT_UNUSED(line);
-
-	return NULL;
-}
-
-char *git_failalloc_strndup(const char *str, size_t n, const char *file, int line)
-{
-	GIT_UNUSED(str);
-	GIT_UNUSED(n);
-	GIT_UNUSED(file);
-	GIT_UNUSED(line);
-
-	return NULL;
-}
-
-char *git_failalloc_substrdup(const char *start, size_t n, const char *file, int line)
-{
-	GIT_UNUSED(start);
-	GIT_UNUSED(n);
-	GIT_UNUSED(file);
-	GIT_UNUSED(line);
-
-	return NULL;
-}
-
 void *git_failalloc_realloc(void *ptr, size_t size, const char *file, int line)
 {
 	GIT_UNUSED(ptr);
@@ -65,27 +26,6 @@ void *git_failalloc_realloc(void *ptr, size_t size, const char *file, int line)
 	return NULL;
 }
 
-void *git_failalloc_reallocarray(void *ptr, size_t nelem, size_t elsize, const char *file, int line)
-{
-	GIT_UNUSED(ptr);
-	GIT_UNUSED(nelem);
-	GIT_UNUSED(elsize);
-	GIT_UNUSED(file);
-	GIT_UNUSED(line);
-
-	return NULL;
-}
-
-void *git_failalloc_mallocarray(size_t nelem, size_t elsize, const char *file, int line)
-{
-	GIT_UNUSED(nelem);
-	GIT_UNUSED(elsize);
-	GIT_UNUSED(file);
-	GIT_UNUSED(line);
-
-	return NULL;
-}
-
 void git_failalloc_free(void *ptr)
 {
 	GIT_UNUSED(ptr);

data/vendor/libgit2/src/util/allocators/failalloc.h

@@ -11,13 +11,7 @@
 #include "git2_util.h"
 
 extern void *git_failalloc_malloc(size_t len, const char *file, int line);
-extern void *git_failalloc_calloc(size_t nelem, size_t elsize, const char *file, int line);
-extern char *git_failalloc_strdup(const char *str, const char *file, int line);
-extern char *git_failalloc_strndup(const char *str, size_t n, const char *file, int line);
-extern char *git_failalloc_substrdup(const char *start, size_t n, const char *file, int line);
 extern void *git_failalloc_realloc(void *ptr, size_t size, const char *file, int line);
-extern void *git_failalloc_reallocarray(void *ptr, size_t nelem, size_t elsize, const char *file, int line);
-extern void *git_failalloc_mallocarray(size_t nelem, size_t elsize, const char *file, int line);
 extern void git_failalloc_free(void *ptr);
 
 #endif