rugged 1.1.1 → 1.2.0

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

@@ -0,0 +1,23 @@
+/*
+ * 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_allocators_failalloc_h__
+#define INCLUDE_allocators_failalloc_h__
+
+#include "common.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

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

@@ -9,34 +9,56 @@
 
 static void *stdalloc__malloc(size_t len, const char *file, int line)
 {
-	void *ptr = malloc(len);
+	void *ptr;
 
 	GIT_UNUSED(file);
 	GIT_UNUSED(line);
 
-	if (!ptr) git_error_set_oom();
+#ifdef GIT_DEBUG_STRICT_ALLOC
+	if (!len)
+		return NULL;
+#endif
+
+	ptr = malloc(len);
+
+	if (!ptr)
+		git_error_set_oom();
+
 	return ptr;
 }
 
 static void *stdalloc__calloc(size_t nelem, size_t elsize, const char *file, int line)
 {
-	void *ptr = calloc(nelem, elsize);
+	void *ptr;
 
 	GIT_UNUSED(file);
 	GIT_UNUSED(line);
 
-	if (!ptr) git_error_set_oom();
+#ifdef GIT_DEBUG_STRICT_ALLOC
+	if (!elsize || !nelem)
+		return NULL;
+#endif
+
+	ptr = calloc(nelem, elsize);
+
+	if (!ptr)
+		git_error_set_oom();
+
 	return ptr;
 }
 
 static char *stdalloc__strdup(const char *str, const char *file, int line)
 {
-	char *ptr = strdup(str);
+	char *ptr;
 
 	GIT_UNUSED(file);
 	GIT_UNUSED(line);
 
-	if (!ptr) git_error_set_oom();
+	ptr = strdup(str);
+
+	if (!ptr)
+		git_error_set_oom();
+
 	return ptr;
 }
 
@@ -48,7 +70,7 @@ static char *stdalloc__strndup(const char *str, size_t n, const char *file, int
 	length = p_strnlen(str, n);
 
 	if (GIT_ADD_SIZET_OVERFLOW(&alloclength, length, 1) ||
-		!(ptr = stdalloc__malloc(alloclength, file, line)))
+	    !(ptr = stdalloc__malloc(alloclength, file, line)))
 		return NULL;
 
 	if (length)
@@ -65,7 +87,7 @@ static char *stdalloc__substrdup(const char *start, size_t n, const char *file,
 	size_t alloclen;
 
 	if (GIT_ADD_SIZET_OVERFLOW(&alloclen, n, 1) ||
-		!(ptr = stdalloc__malloc(alloclen, file, line)))
+	    !(ptr = stdalloc__malloc(alloclen, file, line)))
 		return NULL;
 
 	memcpy(ptr, start, n);
@@ -75,12 +97,21 @@ static char *stdalloc__substrdup(const char *start, size_t n, const char *file,
 
 static void *stdalloc__realloc(void *ptr, size_t size, const char *file, int line)
 {
-	void *new_ptr = realloc(ptr, size);
+	void *new_ptr;
 
 	GIT_UNUSED(file);
 	GIT_UNUSED(line);
 
-	if (!new_ptr) git_error_set_oom();
+#ifdef GIT_DEBUG_STRICT_ALLOC
+	if (!size)
+		return NULL;
+#endif
+
+	new_ptr = realloc(ptr, size);
+
+	if (!new_ptr)
+		git_error_set_oom();
+
 	return new_ptr;
 }
 

data/vendor/libgit2/src/allocators/win32_leakcheck.c

@@ -0,0 +1,118 @@
+/*
+ * 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 "win32_leakcheck.h"
+
+#if defined(GIT_WIN32_LEAKCHECK)
+
+#include "win32/w32_leakcheck.h"
+
+static void *leakcheck_malloc(size_t len, const char *file, int line)
+{
+	void *ptr = _malloc_dbg(len, _NORMAL_BLOCK, git_win32_leakcheck_stacktrace(1,file), line);
+	if (!ptr) git_error_set_oom();
+	return ptr;
+}
+
+static void *leakcheck_calloc(size_t nelem, size_t elsize, const char *file, int line)
+{
+	void *ptr = _calloc_dbg(nelem, elsize, _NORMAL_BLOCK, git_win32_leakcheck_stacktrace(1,file), line);
+	if (!ptr) git_error_set_oom();
+	return ptr;
+}
+
+static char *leakcheck_strdup(const char *str, const char *file, int line)
+{
+	char *ptr = _strdup_dbg(str, _NORMAL_BLOCK, git_win32_leakcheck_stacktrace(1,file), line);
+	if (!ptr) git_error_set_oom();
+	return ptr;
+}
+
+static char *leakcheck_strndup(const char *str, size_t n, const char *file, int line)
+{
+	size_t length = 0, alloclength;
+	char *ptr;
+
+	length = p_strnlen(str, n);
+
+	if (GIT_ADD_SIZET_OVERFLOW(&alloclength, length, 1) ||
+		!(ptr = leakcheck_malloc(alloclength, file, line)))
+		return NULL;
+
+	if (length)
+		memcpy(ptr, str, length);
+
+	ptr[length] = '\0';
+
+	return ptr;
+}
+
+static char *leakcheck_substrdup(const char *start, size_t n, const char *file, int line)
+{
+	char *ptr;
+	size_t alloclen;
+
+	if (GIT_ADD_SIZET_OVERFLOW(&alloclen, n, 1) ||
+		!(ptr = leakcheck_malloc(alloclen, file, line)))
+		return NULL;
+
+	memcpy(ptr, start, n);
+	ptr[n] = '\0';
+	return ptr;
+}
+
+static void *leakcheck_realloc(void *ptr, size_t size, const char *file, int line)
+{
+	void *new_ptr = _realloc_dbg(ptr, size, _NORMAL_BLOCK, git_win32_leakcheck_stacktrace(1,file), line);
+	if (!new_ptr) git_error_set_oom();
+	return new_ptr;
+}
+
+static void *leakcheck_reallocarray(void *ptr, size_t nelem, size_t elsize, const char *file, int line)
+{
+	size_t newsize;
+
+	if (GIT_MULTIPLY_SIZET_OVERFLOW(&newsize, nelem, elsize))
+		return NULL;
+
+	return leakcheck_realloc(ptr, newsize, file, line);
+}
+
+static void *leakcheck_mallocarray(size_t nelem, size_t elsize, const char *file, int line)
+{
+	return leakcheck_reallocarray(NULL, nelem, elsize, file, line);
+}
+
+static void leakcheck_free(void *ptr)
+{
+	free(ptr);
+}
+
+int git_win32_leakcheck_init_allocator(git_allocator *allocator)
+{
+	allocator->gmalloc = leakcheck_malloc;
+	allocator->gcalloc = leakcheck_calloc;
+	allocator->gstrdup = leakcheck_strdup;
+	allocator->gstrndup = leakcheck_strndup;
+	allocator->gsubstrdup = leakcheck_substrdup;
+	allocator->grealloc = leakcheck_realloc;
+	allocator->greallocarray = leakcheck_reallocarray;
+	allocator->gmallocarray = leakcheck_mallocarray;
+	allocator->gfree = leakcheck_free;
+	return 0;
+}
+
+#else
+
+int git_win32_leakcheck_init_allocator(git_allocator *allocator)
+{
+	GIT_UNUSED(allocator);
+	git_error_set(GIT_EINVALID, "leakcheck memory allocator not available");
+	return -1;
+}
+
+#endif

data/vendor/libgit2/src/allocators/{win32_crtdbg.h → win32_leakcheck.h}

@@ -5,13 +5,13 @@
  * a Linking Exception. For full terms see the included COPYING file.
  */
 
-#ifndef INCLUDE_allocators_crtdbg_h
-#define INCLUDE_allocators_crtdbg_h
+#ifndef INCLUDE_allocators_win32_leakcheck_h
+#define INCLUDE_allocators_win32_leakcheck_h
 
 #include "common.h"
 
 #include "alloc.h"
 
-int git_win32_crtdbg_init_allocator(git_allocator *allocator);
+int git_win32_leakcheck_init_allocator(git_allocator *allocator);
 
 #endif

data/vendor/libgit2/src/annotated_commit.c

@@ -26,7 +26,8 @@ static int annotated_commit_init(
 	git_annotated_commit *annotated_commit;
 	int error = 0;
 
-	assert(out && commit);
+	GIT_ASSERT_ARG(out);
+	GIT_ASSERT_ARG(commit);
 
 	*out = NULL;
 
@@ -63,7 +64,9 @@ static int annotated_commit_init_from_id(
 	git_commit *commit = NULL;
 	int error = 0;
 
-	assert(out && repo && id);
+	GIT_ASSERT_ARG(out);
+	GIT_ASSERT_ARG(repo);
+	GIT_ASSERT_ARG(id);
 
 	*out = NULL;
 
@@ -100,7 +103,9 @@ int git_annotated_commit_from_revspec(
 	git_object *obj, *commit;
 	int error;
 
-	assert(out && repo && revspec);
+	GIT_ASSERT_ARG(out);
+	GIT_ASSERT_ARG(repo);
+	GIT_ASSERT_ARG(revspec);
 
 	if ((error = git_revparse_single(&obj, repo, revspec)) < 0)
 		return error;
@@ -126,7 +131,9 @@ int git_annotated_commit_from_ref(
 	git_object *peeled;
 	int error = 0;
 
-	assert(out && repo && ref);
+	GIT_ASSERT_ARG(out);
+	GIT_ASSERT_ARG(repo);
+	GIT_ASSERT_ARG(ref);
 
 	*out = NULL;
 
@@ -154,11 +161,12 @@ int git_annotated_commit_from_head(
 	git_reference *head;
 	int error;
 
-	assert(out && repo);
+	GIT_ASSERT_ARG(out);
+	GIT_ASSERT_ARG(repo);
 
 	*out = NULL;
 
-    if ((error = git_reference_lookup(&head, repo, GIT_HEAD_FILE)) < 0)
+	if ((error = git_reference_lookup(&head, repo, GIT_HEAD_FILE)) < 0)
 		return -1;
 
 	error = git_annotated_commit_from_ref(out, repo, head);
@@ -174,7 +182,11 @@ int git_annotated_commit_from_fetchhead(
 	const char *remote_url,
 	const git_oid *id)
 {
-	assert(repo && id && branch_name && remote_url);
+	GIT_ASSERT_ARG(out);
+	GIT_ASSERT_ARG(repo);
+	GIT_ASSERT_ARG(branch_name);
+	GIT_ASSERT_ARG(remote_url);
+	GIT_ASSERT_ARG(id);
 
 	if (annotated_commit_init_from_id(out, repo, id, branch_name) < 0)
 		return -1;
@@ -192,14 +204,14 @@ int git_annotated_commit_from_fetchhead(
 const git_oid *git_annotated_commit_id(
 	const git_annotated_commit *annotated_commit)
 {
-	assert(annotated_commit);
+	GIT_ASSERT_ARG_WITH_RETVAL(annotated_commit, NULL);
 	return git_commit_id(annotated_commit->commit);
 }
 
 const char *git_annotated_commit_ref(
 	const git_annotated_commit *annotated_commit)
 {
-	assert(annotated_commit);
+	GIT_ASSERT_ARG_WITH_RETVAL(annotated_commit, NULL);
 	return annotated_commit->ref_name;
 }
 

data/vendor/libgit2/src/apply.c

@@ -5,8 +5,6 @@
  * a Linking Exception. For full terms see the included COPYING file.
  */
 
-#include "apply.h"
-
 #include "git2/apply.h"
 #include "git2/patch.h"
 #include "git2/filter.h"
@@ -21,6 +19,7 @@
 #include "zstream.h"
 #include "reader.h"
 #include "index.h"
+#include "apply.h"
 
 typedef struct {
 	/* The lines that we allocate ourself are allocated out of the pool.
@@ -399,7 +398,11 @@ int git_apply__patch(
 	unsigned int mode = 0;
 	int error = 0;
 
-	assert(contents_out && filename_out && mode_out && (source || !source_len) && patch);
+	GIT_ASSERT_ARG(contents_out);
+	GIT_ASSERT_ARG(filename_out);
+	GIT_ASSERT_ARG(mode_out);
+	GIT_ASSERT_ARG(source || !source_len);
+	GIT_ASSERT_ARG(patch);
 
 	if (given_opts)
 		memcpy(&ctx.opts, given_opts, sizeof(git_apply_options));
@@ -624,7 +627,10 @@ int git_apply_to_tree(
 	size_t i;
 	int error = 0;
 
-	assert(out && repo && preimage && diff);
+	GIT_ASSERT_ARG(out);
+	GIT_ASSERT_ARG(repo);
+	GIT_ASSERT_ARG(preimage);
+	GIT_ASSERT_ARG(diff);
 
 	*out = NULL;
 
@@ -772,6 +778,8 @@ done:
 
 int git_apply_options_init(git_apply_options *opts, unsigned int version)
 {
+	GIT_ASSERT_ARG(opts);
+
 	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
 		opts, version, git_apply_options, GIT_APPLY_OPTIONS_INIT);
 	return 0;
@@ -805,7 +813,8 @@ int git_apply(
 	git_apply_options opts = GIT_APPLY_OPTIONS_INIT;
 	int error = GIT_EINVALID;
 
-	assert(repo && diff);
+	GIT_ASSERT_ARG(repo);
+	GIT_ASSERT_ARG(diff);
 
 	GIT_ERROR_CHECK_VERSION(
 		given_opts, GIT_APPLY_OPTIONS_VERSION, "git_apply_options");
@@ -829,7 +838,7 @@ int git_apply(
 		error = git_reader_for_workdir(&pre_reader, repo, false);
 		break;
 	default:
-		assert(false);
+		GIT_ASSERT(false);
 	}
 
 	if (error < 0)
@@ -869,7 +878,7 @@ int git_apply(
 		error = git_apply__to_workdir(repo, diff, preimage, postimage, location, &opts);
 		break;
 	default:
-		assert(false);
+		GIT_ASSERT(false);
 	}
 
 	if (error < 0)

data/vendor/libgit2/src/array.h

@@ -41,8 +41,8 @@
 
 typedef git_array_t(char) git_array_generic_t;
 
-/* use a generic array for growth so this can return the new item */
-GIT_INLINE(void *) git_array_grow(void *_a, size_t item_size)
+/* use a generic array for growth, return 0 on success */
+GIT_INLINE(int) git_array_grow(void *_a, size_t item_size)
 {
 	volatile git_array_generic_t *a = _a;
 	size_t new_size;
@@ -59,24 +59,24 @@ GIT_INLINE(void *) git_array_grow(void *_a, size_t item_size)
 	if ((new_array = git__reallocarray(a->ptr, new_size, item_size)) == NULL)
 		goto on_oom;
 
-	a->ptr = new_array; a->asize = new_size; a->size++;
-	return a->ptr + (a->size - 1) * item_size;
+	a->ptr = new_array;
+	a->asize = new_size;
+	return 0;
 
 on_oom:
 	git_array_clear(*a);
-	return NULL;
+	return -1;
 }
 
 #define git_array_alloc(a) \
-	(((a).size >= (a).asize) ? \
-	git_array_grow(&(a), sizeof(*(a).ptr)) : \
-	((a).ptr ? &(a).ptr[(a).size++] : NULL))
+	(((a).size < (a).asize || git_array_grow(&(a), sizeof(*(a).ptr)) == 0) ? \
+	&(a).ptr[(a).size++] : (void *)NULL)
 
-#define git_array_last(a) ((a).size ? &(a).ptr[(a).size - 1] : NULL)
+#define git_array_last(a) ((a).size ? &(a).ptr[(a).size - 1] : (void *)NULL)
 
-#define git_array_pop(a) ((a).size ? &(a).ptr[--(a).size] : NULL)
+#define git_array_pop(a) ((a).size ? &(a).ptr[--(a).size] : (void *)NULL)
 
-#define git_array_get(a, i) (((i) < (a).size) ? &(a).ptr[(i)] : NULL)
+#define git_array_get(a, i) (((i) < (a).size) ? &(a).ptr[(i)] : (void *)NULL)
 
 #define git_array_size(a) (a).size