rugged 0.19.0 → 0.28.0

data/vendor/libgit2/src/global.c

@@ -4,21 +4,112 @@
  * 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 "common.h"
+
 #include "global.h"
+
+#include "alloc.h"
 #include "hash.h"
-#include "fileops.h"
-#include "git2/threads.h"
+#include "sysdir.h"
+#include "filter.h"
+#include "merge_driver.h"
+#include "streams/registry.h"
+#include "streams/mbedtls.h"
+#include "streams/openssl.h"
 #include "thread-utils.h"
+#include "git2/global.h"
+#include "transports/ssh.h"
 
+#if defined(GIT_MSVC_CRTDBG)
+#include "win32/w32_stack.h"
+#include "win32/w32_crtdbg_stacktrace.h"
+#endif
 
 git_mutex git__mwindow_mutex;
 
+typedef int (*git_global_init_fn)(void);
+
+static git_global_init_fn git__init_callbacks[] = {
+	git_allocator_global_init,
+	git_hash_global_init,
+	git_sysdir_global_init,
+	git_filter_global_init,
+	git_merge_driver_global_init,
+	git_transport_ssh_global_init,
+	git_stream_registry_global_init,
+	git_openssl_stream_global_init,
+	git_mbedtls_stream_global_init,
+	git_mwindow_global_init
+};
+
+static git_global_shutdown_fn git__shutdown_callbacks[ARRAY_SIZE(git__init_callbacks)];
+
+static git_atomic git__n_shutdown_callbacks;
+static git_atomic git__n_inits;
+char *git__user_agent;
+char *git__ssl_ciphers;
+
+void git__on_shutdown(git_global_shutdown_fn callback)
+{
+	int count = git_atomic_inc(&git__n_shutdown_callbacks);
+	assert(count <= (int) ARRAY_SIZE(git__shutdown_callbacks) && count > 0);
+	git__shutdown_callbacks[count - 1] = callback;
+}
+
+static void git__global_state_cleanup(git_global_st *st)
+{
+	if (!st)
+		return;
+
+	git__free(st->error_t.message);
+	st->error_t.message = NULL;
+}
+
+static int init_common(void)
+{
+	size_t i;
+	int ret;
+
+	/* Initialize the CRT debug allocator first, before our first malloc */
+#if defined(GIT_MSVC_CRTDBG)
+	git_win32__crtdbg_stacktrace_init();
+	git_win32__stack_init();
+#endif
+
+	/* Initialize subsystems that have global state */
+	for (i = 0; i < ARRAY_SIZE(git__init_callbacks); i++)
+		if ((ret = git__init_callbacks[i]()) != 0)
+			break;
+
+	GIT_MEMORY_BARRIER;
+
+	return ret;
+}
+
+static void shutdown_common(void)
+{
+	int pos;
+
+	/* Shutdown subsystems that have registered */
+	for (pos = git_atomic_get(&git__n_shutdown_callbacks);
+		pos > 0;
+		pos = git_atomic_dec(&git__n_shutdown_callbacks)) {
+
+		git_global_shutdown_fn cb = git__swap(
+			git__shutdown_callbacks[pos - 1], NULL);
+
+		if (cb != NULL)
+			cb();
+	}
+
+	git__free(git__user_agent);
+	git__free(git__ssl_ciphers);
+}
+
 /**
  * Handle the global state with TLS
  *
  * If libgit2 is built with GIT_THREADS enabled,
- * the `git_threads_init()` function must be called
+ * the `git_libgit2_init()` function must be called
  * before calling any other function of the library.
  *
  * This function allocates a TLS index (using pthreads
@@ -31,7 +122,7 @@ git_mutex git__mwindow_mutex;
  * allocated on each thread.
  *
  * Before shutting down the library, the
- * `git_threads_shutdown` method must be called to free
+ * `git_libgit2_shutdown` method must be called to free
  * the previously reserved TLS index.
  *
  * If libgit2 is built without threading support, the
@@ -41,9 +132,9 @@ git_mutex git__mwindow_mutex;
  */
 
 /*
- * `git_threads_init()` allows subsystems to perform global setup,
+ * `git_libgit2_init()` allows subsystems to perform global setup,
  * which may take place in the global scope.  An explicit memory
- * fence exists at the exit of `git_threads_init()`.  Without this,
+ * fence exists at the exit of `git_libgit2_init()`.  Without this,
  * CPU cores are free to reorder cache invalidation of `_tls_init`
  * before cache invalidation of the subsystems' newly written global
  * state.
@@ -51,121 +142,209 @@ git_mutex git__mwindow_mutex;
 #if defined(GIT_THREADS) && defined(GIT_WIN32)
 
 static DWORD _tls_index;
-static int _tls_init = 0;
+static volatile LONG _mutex = 0;
 
-int git_threads_init(void)
+static int synchronized_threads_init(void)
 {
 	int error;
 
-	if (_tls_init)
-		return 0;
-
 	_tls_index = TlsAlloc();
+
+	git_threads_init();
+
 	if (git_mutex_init(&git__mwindow_mutex))
 		return -1;
 
-	/* Initialize any other subsystems that have global state */
-	if ((error = git_hash_global_init()) >= 0)
-		_tls_init = 1;
+	error = init_common();
 
-	if (error == 0)
-		_tls_init = 1;
+	return error;
+}
 
-	GIT_MEMORY_BARRIER;
+int git_libgit2_init(void)
+{
+	int ret;
 
-	return error;
+	/* Enter the lock */
+	while (InterlockedCompareExchange(&_mutex, 1, 0)) { Sleep(0); }
+
+	/* Only do work on a 0 -> 1 transition of the refcount */
+	if ((ret = git_atomic_inc(&git__n_inits)) == 1) {
+		if (synchronized_threads_init() < 0)
+			ret = -1;
+	}
+
+	/* Exit the lock */
+	InterlockedExchange(&_mutex, 0);
+
+	return ret;
 }
 
-void git_threads_shutdown(void)
+int git_libgit2_shutdown(void)
 {
-	TlsFree(_tls_index);
-	_tls_init = 0;
-	git_mutex_free(&git__mwindow_mutex);
+	int ret;
 
-	/* Shut down any subsystems that have global state */
-	git_hash_global_shutdown();
-	git_futils_dirs_free();
+	/* Enter the lock */
+	while (InterlockedCompareExchange(&_mutex, 1, 0)) { Sleep(0); }
+
+	/* Only do work on a 1 -> 0 transition of the refcount */
+	if ((ret = git_atomic_dec(&git__n_inits)) == 0) {
+		shutdown_common();
+
+		git__free_tls_data();
+
+		TlsFree(_tls_index);
+		git_mutex_free(&git__mwindow_mutex);
+
+#if defined(GIT_MSVC_CRTDBG)
+		git_win32__crtdbg_stacktrace_cleanup();
+		git_win32__stack_cleanup();
+#endif
+	}
+
+	/* Exit the lock */
+	InterlockedExchange(&_mutex, 0);
+
+	return ret;
 }
 
 git_global_st *git__global_state(void)
 {
-	void *ptr;
+	git_global_st *ptr;
 
-	assert(_tls_init);
+	assert(git_atomic_get(&git__n_inits) > 0);
 
 	if ((ptr = TlsGetValue(_tls_index)) != NULL)
 		return ptr;
 
-	ptr = git__malloc(sizeof(git_global_st));
+	ptr = git__calloc(1, sizeof(git_global_st));
 	if (!ptr)
 		return NULL;
 
-	memset(ptr, 0x0, sizeof(git_global_st));
+	git_buf_init(&ptr->error_buf, 0);
+
 	TlsSetValue(_tls_index, ptr);
 	return ptr;
 }
 
+/**
+ * Free the TLS data associated with this thread.
+ * This should only be used by the thread as it
+ * is exiting.
+ */
+void git__free_tls_data(void)
+{
+	void *ptr = TlsGetValue(_tls_index);
+	if (!ptr)
+		return;
+
+	git__global_state_cleanup(ptr);
+	git__free(ptr);
+	TlsSetValue(_tls_index, NULL);
+}
+
+BOOL WINAPI DllMain(HINSTANCE hInstDll, DWORD fdwReason, LPVOID lpvReserved)
+{
+	GIT_UNUSED(hInstDll);
+	GIT_UNUSED(lpvReserved);
+
+	/* This is how Windows lets us know our thread is being shut down */
+	if (fdwReason == DLL_THREAD_DETACH) {
+		git__free_tls_data();
+	}
+
+	/*
+	 * Windows pays attention to this during library loading. We don't do anything
+	 * so we trivially succeed.
+	 */
+	return TRUE;
+}
+
 #elif defined(GIT_THREADS) && defined(_POSIX_THREADS)
 
 static pthread_key_t _tls_key;
-static int _tls_init = 0;
+static pthread_mutex_t _init_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_once_t _once_init = PTHREAD_ONCE_INIT;
+int init_error = 0;
 
 static void cb__free_status(void *st)
 {
+	git__global_state_cleanup(st);
 	git__free(st);
 }
 
-int git_threads_init(void)
+static void init_once(void)
 {
-	int error = 0;
-
-	if (_tls_init)
-		return 0;
+	if ((init_error = git_mutex_init(&git__mwindow_mutex)) != 0)
+		return;
 
-	if (git_mutex_init(&git__mwindow_mutex))
-		return -1;
 	pthread_key_create(&_tls_key, &cb__free_status);
 
-	/* Initialize any other subsystems that have global state */
-	if ((error = git_hash_global_init()) >= 0)
-		_tls_init = 1;
+	init_error = init_common();
+}
+
+int git_libgit2_init(void)
+{
+	int ret, err;
 
-	GIT_MEMORY_BARRIER;
+	if ((err = pthread_mutex_lock(&_init_mutex)) != 0)
+		return err;
 
-	return error;
+	ret = git_atomic_inc(&git__n_inits);
+	err = pthread_once(&_once_init, init_once);
+	err |= pthread_mutex_unlock(&_init_mutex);
+
+	if (err || init_error)
+		return err | init_error;
+
+	return ret;
 }
 
-void git_threads_shutdown(void)
+int git_libgit2_shutdown(void)
 {
-	if (_tls_init) {
-		void *ptr = pthread_getspecific(_tls_key);
-		pthread_setspecific(_tls_key, NULL);
-		git__free(ptr);
-	}
+	void *ptr = NULL;
+	pthread_once_t new_once = PTHREAD_ONCE_INIT;
+	int error, ret;
+
+	if ((error = pthread_mutex_lock(&_init_mutex)) != 0)
+		return error;
+
+	if ((ret = git_atomic_dec(&git__n_inits)) != 0)
+		goto out;
+
+	/* Shut down any subsystems that have global state */
+	shutdown_common();
+
+	ptr = pthread_getspecific(_tls_key);
+	pthread_setspecific(_tls_key, NULL);
+
+	git__global_state_cleanup(ptr);
+	git__free(ptr);
 
 	pthread_key_delete(_tls_key);
-	_tls_init = 0;
 	git_mutex_free(&git__mwindow_mutex);
+	_once_init = new_once;
 
-	/* Shut down any subsystems that have global state */
-	git_hash_global_shutdown();
-	git_futils_dirs_free();
+out:
+	if ((error = pthread_mutex_unlock(&_init_mutex)) != 0)
+		return error;
+
+	return ret;
 }
 
 git_global_st *git__global_state(void)
 {
-	void *ptr;
+	git_global_st *ptr;
 
-	assert(_tls_init);
+	assert(git_atomic_get(&git__n_inits) > 0);
 
 	if ((ptr = pthread_getspecific(_tls_key)) != NULL)
 		return ptr;
 
-	ptr = git__malloc(sizeof(git_global_st));
+	ptr = git__calloc(1, sizeof(git_global_st));
 	if (!ptr)
 		return NULL;
 
-	memset(ptr, 0x0, sizeof(git_global_st));
+	git_buf_init(&ptr->error_buf, 0);
 	pthread_setspecific(_tls_key, ptr);
 	return ptr;
 }
@@ -174,17 +353,32 @@ git_global_st *git__global_state(void)
 
 static git_global_st __state;
 
-int git_threads_init(void)
+int git_libgit2_init(void)
 {
-	/* noop */ 
-	return 0;
+	int ret;
+
+	/* Only init subsystems the first time */
+	if ((ret = git_atomic_inc(&git__n_inits)) != 1)
+		return ret;
+
+	if ((ret = init_common()) < 0)
+		return ret;
+
+	return 1;
 }
 
-void git_threads_shutdown(void)
+int git_libgit2_shutdown(void)
 {
+	int ret;
+
 	/* Shut down any subsystems that have global state */
-	git_hash_global_shutdown();
-	git_futils_dirs_free();
+	if ((ret = git_atomic_dec(&git__n_inits)) == 0) {
+		shutdown_common();
+		git__global_state_cleanup(&__state);
+		memset(&__state, 0, sizeof(__state));
+	}
+
+	return ret;
 }
 
 git_global_st *git__global_state(void)

data/vendor/libgit2/src/global.h

@@ -7,12 +7,22 @@
 #ifndef INCLUDE_global_h__
 #define INCLUDE_global_h__
 
+#include "common.h"
+
 #include "mwindow.h"
 #include "hash.h"
 
 typedef struct {
 	git_error *last_error;
 	git_error error_t;
+	git_buf error_buf;
+	char oid_fmt[GIT_OID_HEXSZ+1];
+
+	/* On Windows, this is the current child thread that was started by
+	 * `git_thread_create`.  This is used to set the thread's exit code
+	 * when terminated by `git_thread_exit`.  It is unused on POSIX.
+	 */
+	git_thread *current_thread;
 } git_global_st;
 
 git_global_st *git__global_state(void);
@@ -21,4 +31,13 @@ extern git_mutex git__mwindow_mutex;
 
 #define GIT_GLOBAL (git__global_state())
 
+typedef void (*git_global_shutdown_fn)(void);
+
+extern void git__on_shutdown(git_global_shutdown_fn callback);
+
+extern void git__free_tls_data(void);
+
+extern const char *git_libgit2__user_agent(void);
+extern const char *git_libgit2__ssl_ciphers(void);
+
 #endif

data/vendor/libgit2/src/graph.c

@@ -1,4 +1,3 @@
-
 /*
  * Copyright (C) the libgit2 contributors. All rights reserved.
  *
@@ -6,6 +5,8 @@
  * a Linking Exception. For full terms see the included COPYING file.
  */
 
+#include "common.h"
+
 #include "revwalk.h"
 #include "merge.h"
 #include "git2/graph.h"
@@ -13,9 +14,9 @@
 static int interesting(git_pqueue *list, git_commit_list *roots)
 {
 	unsigned int i;
-	/* element 0 isn't used - we need to start at 1 */
-	for (i = 1; i < list->size; i++) {
-		git_commit_list_node *commit = list->d[i];
+
+	for (i = 0; i < git_pqueue_size(list); i++) {
+		git_commit_list_node *commit = git_pqueue_get(list, i);
 		if ((commit->flags & STALE) == 0)
 			return 1;
 	}
@@ -42,7 +43,7 @@ static int mark_parents(git_revwalk *walk, git_commit_list_node *one,
 		return 0;
 	}
 
-	if (git_pqueue_init(&list, 2, git_commit_list_time_cmp) < 0)
+	if (git_pqueue_init(&list, 0, 2, git_commit_list_time_cmp) < 0)
 		return -1;
 
 	if (git_commit_list_parse(walk, one) < 0)
@@ -59,10 +60,9 @@ static int mark_parents(git_revwalk *walk, git_commit_list_node *one,
 
 	/* as long as there are non-STALE commits */
 	while (interesting(&list, roots)) {
-		git_commit_list_node *commit;
-		int flags;
+		git_commit_list_node *commit = git_pqueue_pop(&list);
+		unsigned int flags;
 
-		commit = git_pqueue_pop(&list);
 		if (commit == NULL)
 			break;
 
@@ -110,40 +110,37 @@ static int ahead_behind(git_commit_list_node *one, git_commit_list_node *two,
 {
 	git_commit_list_node *commit;
 	git_pqueue pq;
-	int i;
+	int error = 0, i;
 	*ahead = 0;
 	*behind = 0;
 
-	if (git_pqueue_init(&pq, 2, git_commit_list_time_cmp) < 0)
+	if (git_pqueue_init(&pq, 0, 2, git_commit_list_time_cmp) < 0)
 		return -1;
-	if (git_pqueue_insert(&pq, one) < 0)
-		goto on_error;
-	if (git_pqueue_insert(&pq, two) < 0)
-		goto on_error;
+
+	if ((error = git_pqueue_insert(&pq, one)) < 0 ||
+		(error = git_pqueue_insert(&pq, two)) < 0)
+		goto done;
 
 	while ((commit = git_pqueue_pop(&pq)) != NULL) {
 		if (commit->flags & RESULT ||
 			(commit->flags & (PARENT1 | PARENT2)) == (PARENT1 | PARENT2))
 			continue;
 		else if (commit->flags & PARENT1)
-			(*behind)++;
-		else if (commit->flags & PARENT2)
 			(*ahead)++;
+		else if (commit->flags & PARENT2)
+			(*behind)++;
 
 		for (i = 0; i < commit->out_degree; i++) {
 			git_commit_list_node *p = commit->parents[i];
-			if (git_pqueue_insert(&pq, p) < 0)
-				return -1;
+			if ((error = git_pqueue_insert(&pq, p)) < 0)
+				goto done;
 		}
 		commit->flags |= RESULT;
 	}
 
+done:
 	git_pqueue_free(&pq);
-	return 0;
-
-on_error:
-	git_pqueue_free(&pq);
-	return -1;
+	return error;
 }
 
 int git_graph_ahead_behind(size_t *ahead, size_t *behind, git_repository *repo,
@@ -176,3 +173,22 @@ on_error:
 	git_revwalk_free(walk);
 	return -1;
 }
+
+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 0;
+
+	if (error < 0)
+		return error;
+
+	return git_oid_equal(&merge_base, ancestor);
+}

data/vendor/libgit2/src/hash/hash_collisiondetect.h

@@ -0,0 +1,51 @@
+/*
+ * 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_hash_hash_collisiondetect_h__
+#define INCLUDE_hash_hash_collisiondetect_h__
+
+#include "hash.h"
+#include "sha1dc/sha1.h"
+
+struct git_hash_ctx {
+	SHA1_CTX c;
+};
+
+#define git_hash_ctx_init(ctx) git_hash_init(ctx)
+#define git_hash_ctx_cleanup(ctx)
+
+GIT_INLINE(int) git_hash_global_init(void)
+{
+	return 0;
+}
+
+GIT_INLINE(int) git_hash_init(git_hash_ctx *ctx)
+{
+	assert(ctx);
+	SHA1DCInit(&ctx->c);
+	return 0;
+}
+
+GIT_INLINE(int) git_hash_update(git_hash_ctx *ctx, const void *data, size_t len)
+{
+	assert(ctx);
+	SHA1DCUpdate(&ctx->c, data, len);
+	return 0;
+}
+
+GIT_INLINE(int) git_hash_final(git_oid *out, git_hash_ctx *ctx)
+{
+	assert(ctx);
+	if (SHA1DCFinal(out->id, &ctx->c)) {
+		git_error_set(GIT_ERROR_SHA1, "SHA1 collision attack detected");
+		return -1;
+	}
+
+	return 0;
+}
+
+#endif

data/vendor/libgit2/src/hash/hash_common_crypto.h

@@ -0,0 +1,61 @@
+/*
+ * 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_hash_hash_common_crypto_h__
+#define INCLUDE_hash_hash_common_crypto_h__
+
+#include "hash.h"
+
+#include <CommonCrypto/CommonDigest.h>
+
+struct git_hash_ctx {
+	CC_SHA1_CTX c;
+};
+
+#define CC_LONG_MAX ((CC_LONG)-1)
+
+#define git_hash_ctx_init(ctx) git_hash_init(ctx)
+#define git_hash_ctx_cleanup(ctx)
+
+GIT_INLINE(int) git_hash_global_init(void)
+{
+	return 0;
+}
+
+GIT_INLINE(int) git_hash_init(git_hash_ctx *ctx)
+{
+	assert(ctx);
+	CC_SHA1_Init(&ctx->c);
+	return 0;
+}
+
+GIT_INLINE(int) git_hash_update(git_hash_ctx *ctx, const void *_data, size_t len)
+{
+	const unsigned char *data = _data;
+
+	assert(ctx);
+
+	while (len > 0) {
+		CC_LONG chunk = (len > CC_LONG_MAX) ? CC_LONG_MAX : (CC_LONG)len;
+
+		CC_SHA1_Update(&ctx->c, data, chunk);
+
+		data += chunk;
+		len -= chunk;
+	}
+
+	return 0;
+}
+
+GIT_INLINE(int) git_hash_final(git_oid *out, git_hash_ctx *ctx)
+{
+	assert(ctx);
+	CC_SHA1_Final(out->id, &ctx->c);
+	return 0;
+}
+
+#endif