rugged 1.0.0 → 1.2.0

data/vendor/libgit2/src/filter.h

@@ -11,29 +11,39 @@
 
 #include "attr_file.h"
 #include "git2/filter.h"
+#include "git2/sys/filter.h"
 
 /* Amount of file to examine for NUL byte when checking binary-ness */
 #define GIT_FILTER_BYTES_TO_CHECK_NUL 8000
 
 typedef struct {
+	git_filter_options options;
 	git_attr_session *attr_session;
 	git_buf *temp_buf;
-	uint32_t flags;
-} git_filter_options;
+} git_filter_session;
 
-#define GIT_FILTER_OPTIONS_INIT {0}
+#define GIT_FILTER_SESSION_INIT {GIT_FILTER_OPTIONS_INIT, 0}
 
 extern int git_filter_global_init(void);
 
 extern void git_filter_free(git_filter *filter);
 
-extern int git_filter_list__load_ext(
+extern int git_filter_list__load(
 	git_filter_list **filters,
 	git_repository *repo,
 	git_blob *blob, /* can be NULL */
 	const char *path,
 	git_filter_mode_t mode,
-	git_filter_options *filter_opts);
+	git_filter_session *filter_session);
+
+/*
+ * The given input buffer will be converted to the given output buffer.
+ * The input buffer will be freed (_if_ it was allocated).
+ */
+extern int git_filter_list__convert_buf(
+	git_buf *out,
+	git_filter_list *filters,
+	git_buf *in);
 
 /*
  * Available filters
@@ -42,4 +52,13 @@ extern int git_filter_list__load_ext(
 extern git_filter *git_crlf_filter_new(void);
 extern git_filter *git_ident_filter_new(void);
 
+extern int git_filter_buffered_stream_new(
+	git_writestream **out,
+	git_filter *filter,
+	int (*write_fn)(git_filter *, void **, git_buf *, const git_buf *, const git_filter_source *),
+	git_buf *temp_buf,
+	void **payload,
+	const git_filter_source *source,
+	git_writestream *target);
+
 #endif

data/vendor/libgit2/src/futils.c

@@ -7,8 +7,9 @@
 
 #include "futils.h"
 
-#include "global.h"
+#include "runtime.h"
 #include "strmap.h"
+#include "hash.h"
 #include <ctype.h>
 #if GIT_WIN32
 #include "win32/findfile.h"
@@ -184,7 +185,8 @@ int git_futils_readbuffer_updated(
 	git_buf buf = GIT_BUF_INIT;
 	git_oid checksum_new;
 
-	assert(out && path && *path);
+	GIT_ASSERT_ARG(out);
+	GIT_ASSERT_ARG(path && *path);
 
 	if (updated != NULL)
 		*updated = 0;
@@ -492,7 +494,7 @@ int git_futils_mkdir(
 			goto done;
 		}
 
-		assert(len);
+		GIT_ASSERT(len);
 
 		/*
 		 * We've walked all the given path's parents and it's either relative
@@ -834,12 +836,12 @@ int git_futils_rmdir_r(
 	return error;
 }
 
-int git_futils_fake_symlink(const char *old, const char *new)
+int git_futils_fake_symlink(const char *target, const char *path)
 {
 	int retcode = GIT_ERROR;
-	int fd = git_futils_creat_withpath(new, 0755, 0644);
+	int fd = git_futils_creat_withpath(path, 0755, 0644);
 	if (fd >= 0) {
-		retcode = p_write(fd, old, strlen(old));
+		retcode = p_write(fd, target, strlen(target));
 		p_close(fd);
 	}
 	return retcode;
@@ -1127,8 +1129,6 @@ int git_futils_filestamp_check(
 void git_futils_filestamp_set(
 	git_futils_filestamp *target, const git_futils_filestamp *source)
 {
-	assert(target);
-
 	if (source)
 		memcpy(target, source, sizeof(*target));
 	else

data/vendor/libgit2/src/futils.h

@@ -257,7 +257,7 @@ extern int git_futils_truncate(const char *path, int mode);
  */
 extern int git_futils_filesize(uint64_t *out, git_file fd);
 
-#define GIT_PERMS_IS_EXEC(MODE)		(((MODE) & 0111) != 0)
+#define GIT_PERMS_IS_EXEC(MODE)		(((MODE) & 0100) != 0)
 #define GIT_PERMS_CANONICAL(MODE)	(GIT_PERMS_IS_EXEC(MODE) ? 0755 : 0644)
 #define GIT_PERMS_FOR_WRITE(MODE)   (GIT_PERMS_IS_EXEC(MODE) ? 0777 : 0666)
 
@@ -316,11 +316,11 @@ extern void git_futils_mmap_free(git_map *map);
 /**
  * Create a "fake" symlink (text file containing the target path).
  *
- * @param new symlink file to be created
- * @param old original symlink target
+ * @param target original symlink target
+ * @param path symlink file to be created
  * @return 0 on success, -1 on error
  */
-extern int git_futils_fake_symlink(const char *new, const char *old);
+extern int git_futils_fake_symlink(const char *target, const char *path);
 
 /**
  * A file stamp represents a snapshot of information about a file that can

data/vendor/libgit2/src/graph.c

@@ -43,7 +43,7 @@ static int mark_parents(git_revwalk *walk, git_commit_list_node *one,
 		return 0;
 	}
 
-	if (git_pqueue_init(&list, 0, 2, git_commit_list_time_cmp) < 0)
+	if (git_pqueue_init(&list, 0, 2, git_commit_list_generation_cmp) < 0)
 		return -1;
 
 	if (git_commit_list_parse(walk, one) < 0)
@@ -176,19 +176,74 @@ on_error:
 
 int git_graph_descendant_of(git_repository *repo, const git_oid *commit, const git_oid *ancestor)
 {
-	git_oid merge_base;
-	int error;
-
 	if (git_oid_equal(commit, ancestor))
 		return 0;
 
-	error = git_merge_base(&merge_base, repo, commit, ancestor);
-	/* No merge-base found, it's not a descendant */
-	if (error == GIT_ENOTFOUND)
+	return git_graph_reachable_from_any(repo, ancestor, commit, 1);
+}
+
+int git_graph_reachable_from_any(
+		git_repository *repo,
+		const git_oid *commit_id,
+		const git_oid descendant_array[],
+		size_t length)
+{
+	git_revwalk *walk = NULL;
+	git_vector list;
+	git_commit_list *result = NULL;
+	git_commit_list_node *commit;
+	size_t i;
+	uint32_t minimum_generation = 0xffffffff;
+	int error = 0;
+
+	if (!length)
 		return 0;
 
-	if (error < 0)
+	for (i = 0; i < length; ++i) {
+		if (git_oid_equal(commit_id, &descendant_array[i]))
+			return 1;
+	}
+
+	if ((error = git_vector_init(&list, length + 1, NULL)) < 0)
 		return error;
 
-	return git_oid_equal(&merge_base, ancestor);
+	if ((error = git_revwalk_new(&walk, repo)) < 0)
+		goto done;
+
+	for (i = 0; i < length; i++) {
+		commit = git_revwalk__commit_lookup(walk, &descendant_array[i]);
+		if (commit == NULL) {
+			error = -1;
+			goto done;
+		}
+
+		git_vector_insert(&list, commit);
+		if (minimum_generation > commit->generation)
+			minimum_generation = commit->generation;
+	}
+
+	commit = git_revwalk__commit_lookup(walk, commit_id);
+	if (commit == NULL) {
+		error = -1;
+		goto done;
+	}
+
+	if (minimum_generation > commit->generation)
+		minimum_generation = commit->generation;
+
+	if ((error = git_merge__bases_many(&result, walk, commit, &list, minimum_generation)) < 0)
+		goto done;
+
+	if (result) {
+		error = git_oid_equal(commit_id, &result->item->oid);
+	} else {
+		/* No merge-base found, it's not a descendant */
+		error = 0;
+	}
+
+done:
+	git_commit_list_free(&result);
+	git_vector_free(&list);
+	git_revwalk_free(walk);
+	return error;
 }

data/vendor/libgit2/src/hash/sha1/collisiondetect.c

@@ -24,21 +24,21 @@ void git_hash_sha1_ctx_cleanup(git_hash_sha1_ctx *ctx)
 
 int git_hash_sha1_init(git_hash_sha1_ctx *ctx)
 {
-	assert(ctx);
+	GIT_ASSERT_ARG(ctx);
 	SHA1DCInit(&ctx->c);
 	return 0;
 }
 
 int git_hash_sha1_update(git_hash_sha1_ctx *ctx, const void *data, size_t len)
 {
-	assert(ctx);
+	GIT_ASSERT_ARG(ctx);
 	SHA1DCUpdate(&ctx->c, data, len);
 	return 0;
 }
 
 int git_hash_sha1_final(git_oid *out, git_hash_sha1_ctx *ctx)
 {
-	assert(ctx);
+	GIT_ASSERT_ARG(ctx);
 	if (SHA1DCFinal(out->id, &ctx->c)) {
 		git_error_set(GIT_ERROR_SHA1, "SHA1 collision attack detected");
 		return -1;

data/vendor/libgit2/src/hash/sha1/common_crypto.c

@@ -26,7 +26,7 @@ void git_hash_sha1_ctx_cleanup(git_hash_sha1_ctx *ctx)
 
 int git_hash_sha1_init(git_hash_sha1_ctx *ctx)
 {
-	assert(ctx);
+	GIT_ASSERT_ARG(ctx);
 	CC_SHA1_Init(&ctx->c);
 	return 0;
 }
@@ -35,7 +35,7 @@ int git_hash_sha1_update(git_hash_sha1_ctx *ctx, const void *_data, size_t len)
 {
 	const unsigned char *data = _data;
 
-	assert(ctx);
+	GIT_ASSERT_ARG(ctx);
 
 	while (len > 0) {
 		CC_LONG chunk = (len > CC_LONG_MAX) ? CC_LONG_MAX : (CC_LONG)len;
@@ -51,7 +51,7 @@ int git_hash_sha1_update(git_hash_sha1_ctx *ctx, const void *_data, size_t len)
 
 int git_hash_sha1_final(git_oid *out, git_hash_sha1_ctx *ctx)
 {
-	assert(ctx);
+	GIT_ASSERT_ARG(ctx);
 	CC_SHA1_Final(out->id, &ctx->c);
 	return 0;
 }

data/vendor/libgit2/src/hash/sha1/generic.h

@@ -11,7 +11,7 @@
 #include "hash/sha1.h"
 
 struct git_hash_sha1_ctx {
-	unsigned long long size;
+	uint64_t size;
 	unsigned int H[5];
 	unsigned int W[16];
 };

data/vendor/libgit2/src/hash/sha1/mbedtls.c

@@ -19,28 +19,28 @@ int git_hash_sha1_ctx_init(git_hash_sha1_ctx *ctx)
 
 void git_hash_sha1_ctx_cleanup(git_hash_sha1_ctx *ctx)
 {
-    assert(ctx);
-    mbedtls_sha1_free(&ctx->c);
+	if (ctx)
+		mbedtls_sha1_free(&ctx->c);
 }
 
 int git_hash_sha1_init(git_hash_sha1_ctx *ctx)
 {
-    assert(ctx);
-    mbedtls_sha1_init(&ctx->c);
-    mbedtls_sha1_starts(&ctx->c);
-    return 0;
+	GIT_ASSERT_ARG(ctx);
+	mbedtls_sha1_init(&ctx->c);
+	mbedtls_sha1_starts(&ctx->c);
+	return 0;
 }
 
 int git_hash_sha1_update(git_hash_sha1_ctx *ctx, const void *data, size_t len)
 {
-    assert(ctx);
-    mbedtls_sha1_update(&ctx->c, data, len);
-    return 0;
+	GIT_ASSERT_ARG(ctx);
+	mbedtls_sha1_update(&ctx->c, data, len);
+	return 0;
 }
 
 int git_hash_sha1_final(git_oid *out, git_hash_sha1_ctx *ctx)
 {
-    assert(ctx);
-    mbedtls_sha1_finish(&ctx->c, out->id);
-    return 0;
+	GIT_ASSERT_ARG(ctx);
+	mbedtls_sha1_finish(&ctx->c, out->id);
+	return 0;
 }

data/vendor/libgit2/src/hash/sha1/openssl.c

@@ -24,7 +24,7 @@ void git_hash_sha1_ctx_cleanup(git_hash_sha1_ctx *ctx)
 
 int git_hash_sha1_init(git_hash_sha1_ctx *ctx)
 {
-	assert(ctx);
+	GIT_ASSERT_ARG(ctx);
 
 	if (SHA1_Init(&ctx->c) != 1) {
 		git_error_set(GIT_ERROR_SHA1, "hash_openssl: failed to initialize hash context");
@@ -36,7 +36,7 @@ int git_hash_sha1_init(git_hash_sha1_ctx *ctx)
 
 int git_hash_sha1_update(git_hash_sha1_ctx *ctx, const void *data, size_t len)
 {
-	assert(ctx);
+	GIT_ASSERT_ARG(ctx);
 
 	if (SHA1_Update(&ctx->c, data, len) != 1) {
 		git_error_set(GIT_ERROR_SHA1, "hash_openssl: failed to update hash");
@@ -48,7 +48,7 @@ int git_hash_sha1_update(git_hash_sha1_ctx *ctx, const void *data, size_t len)
 
 int git_hash_sha1_final(git_oid *out, git_hash_sha1_ctx *ctx)
 {
-	assert(ctx);
+	GIT_ASSERT_ARG(ctx);
 
 	if (SHA1_Final(out->id, &ctx->c) != 1) {
 		git_error_set(GIT_ERROR_SHA1, "hash_openssl: failed to finalize hash");

data/vendor/libgit2/src/hash/sha1/sha1dc/sha1.c

@@ -10,10 +10,8 @@
 #include <memory.h>
 #include <stdio.h>
 #include <stdlib.h>
-#ifdef __unix__
 #include <sys/types.h> /* make sure macros like _BIG_ENDIAN visible */
 #endif
-#endif
 
 #ifdef SHA1DC_CUSTOM_INCLUDE_SHA1_C
 #include SHA1DC_CUSTOM_INCLUDE_SHA1_C

data/vendor/libgit2/src/hash/sha1/win32.c

@@ -7,7 +7,7 @@
 
 #include "win32.h"
 
-#include "global.h"
+#include "runtime.h"
 
 #include <wincrypt.h>
 #include <strsafe.h>
@@ -129,7 +129,8 @@ int git_hash_sha1_global_init(void)
 	if ((error = hash_cng_prov_init()) < 0)
 		error = hash_cryptoapi_prov_init();
 
-	git__on_shutdown(sha1_shutdown);
+	if (!error)
+		error = git_runtime_shutdown_register(sha1_shutdown);
 
 	return error;
 }
@@ -163,7 +164,7 @@ GIT_INLINE(int) hash_cryptoapi_update(git_hash_sha1_ctx *ctx, const void *_data,
 {
 	const BYTE *data = (BYTE *)_data;
 
-	assert(ctx->ctx.cryptoapi.valid);
+	GIT_ASSERT(ctx->ctx.cryptoapi.valid);
 
 	while (len > 0) {
 		DWORD chunk = (len > MAXDWORD) ? MAXDWORD : (DWORD)len;
@@ -185,7 +186,7 @@ GIT_INLINE(int) hash_cryptoapi_final(git_oid *out, git_hash_sha1_ctx *ctx)
 	DWORD len = 20;
 	int error = 0;
 
-	assert(ctx->ctx.cryptoapi.valid);
+	GIT_ASSERT(ctx->ctx.cryptoapi.valid);
 
 	if (!CryptGetHashParam(ctx->ctx.cryptoapi.hash_handle, HP_HASHVAL, out->id, &len, 0)) {
 		git_error_set(GIT_ERROR_OS, "legacy hash data could not be finished");
@@ -285,7 +286,7 @@ int git_hash_sha1_ctx_init(git_hash_sha1_ctx *ctx)
 {
 	int error = 0;
 
-	assert(ctx);
+	GIT_ASSERT_ARG(ctx);
 
 	/*
 	 * When compiled with GIT_THREADS, the global hash_prov data is
@@ -302,27 +303,30 @@ int git_hash_sha1_ctx_init(git_hash_sha1_ctx *ctx)
 
 int git_hash_sha1_init(git_hash_sha1_ctx *ctx)
 {
-	assert(ctx && ctx->type);
+	GIT_ASSERT_ARG(ctx);
+	GIT_ASSERT_ARG(ctx->type);
 	return (ctx->type == CNG) ? hash_cng_init(ctx) : hash_cryptoapi_init(ctx);
 }
 
 int git_hash_sha1_update(git_hash_sha1_ctx *ctx, const void *data, size_t len)
 {
-	assert(ctx && ctx->type);
+	GIT_ASSERT_ARG(ctx);
+	GIT_ASSERT_ARG(ctx->type);
 	return (ctx->type == CNG) ? hash_cng_update(ctx, data, len) : hash_cryptoapi_update(ctx, data, len);
 }
 
 int git_hash_sha1_final(git_oid *out, git_hash_sha1_ctx *ctx)
 {
-	assert(ctx && ctx->type);
+	GIT_ASSERT_ARG(ctx);
+	GIT_ASSERT_ARG(ctx->type);
 	return (ctx->type == CNG) ? hash_cng_final(out, ctx) : hash_cryptoapi_final(out, ctx);
 }
 
 void git_hash_sha1_ctx_cleanup(git_hash_sha1_ctx *ctx)
 {
-	assert(ctx);
-
-	if (ctx->type == CNG)
+	if (!ctx)
+		return;
+	else if (ctx->type == CNG)
 		hash_ctx_cng_cleanup(ctx);
 	else if(ctx->type == CRYPTOAPI)
 		hash_ctx_cryptoapi_cleanup(ctx);