rugged 0.27.9 → 0.27.10

data/vendor/libgit2/src/{fileops.h → futils.h}

@@ -4,8 +4,8 @@
  * 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_fileops_h__
-#define INCLUDE_fileops_h__
+#ifndef INCLUDE_futils_h__
+#define INCLUDE_futils_h__
 
 #include "common.h"
 
@@ -255,7 +255,7 @@ extern int git_futils_truncate(const char *path, int mode);
 /**
  * Get the filesize in bytes of a file
  */
-extern git_off_t git_futils_filesize(git_file fd);
+extern int git_futils_filesize(uint64_t *out, git_file fd);
 
 #define GIT_PERMS_IS_EXEC(MODE)		(((MODE) & 0111) != 0)
 #define GIT_PERMS_CANONICAL(MODE)	(GIT_PERMS_IS_EXEC(MODE) ? 0755 : 0644)
@@ -290,7 +290,7 @@ extern mode_t git_futils_canonical_mode(mode_t raw_mode);
 extern int git_futils_mmap_ro(
 	git_map *out,
 	git_file fd,
-	git_off_t begin,
+	off64_t begin,
 	size_t len);
 
 /**
@@ -330,7 +330,7 @@ extern int git_futils_fake_symlink(const char *new, const char *old);
  */
 typedef struct {
 	struct timespec mtime;
-	git_off_t  size;
+	uint64_t size;
 	unsigned int ino;
 } git_futils_filestamp;
 
@@ -340,7 +340,7 @@ typedef struct {
  * This function updates the file stamp to current data for the given path
  * and returns 0 if the file is up-to-date relative to the prior setting,
  * 1 if the file has been changed, or GIT_ENOTFOUND if the file doesn't
- * exist.  This will not call giterr_set, so you must set the error if you
+ * exist.  This will not call git_error_set, so you must set the error if you
  * plan to return an error.
  *
  * @param stamp File stamp to be checked

data/vendor/libgit2/src/global.c

@@ -7,11 +7,13 @@
 
 #include "global.h"
 
+#include "alloc.h"
 #include "hash.h"
 #include "sysdir.h"
 #include "filter.h"
 #include "merge_driver.h"
-#include "streams/curl.h"
+#include "streams/registry.h"
+#include "streams/mbedtls.h"
 #include "streams/openssl.h"
 #include "thread-utils.h"
 #include "git2/global.h"
@@ -24,9 +26,23 @@
 
 git_mutex git__mwindow_mutex;
 
-#define MAX_SHUTDOWN_CB 10
+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_global_shutdown_fn git__shutdown_callbacks[MAX_SHUTDOWN_CB];
 static git_atomic git__n_shutdown_callbacks;
 static git_atomic git__n_inits;
 char *git__user_agent;
@@ -35,7 +51,7 @@ char *git__ssl_ciphers;
 void git__on_shutdown(git_global_shutdown_fn callback)
 {
 	int count = git_atomic_inc(&git__n_shutdown_callbacks);
-	assert(count <= MAX_SHUTDOWN_CB && count > 0);
+	assert(count <= (int) ARRAY_SIZE(git__shutdown_callbacks) && count > 0);
 	git__shutdown_callbacks[count - 1] = callback;
 }
 
@@ -50,6 +66,7 @@ static void git__global_state_cleanup(git_global_st *st)
 
 static int init_common(void)
 {
+	size_t i;
 	int ret;
 
 	/* Initialize the CRT debug allocator first, before our first malloc */
@@ -58,15 +75,10 @@ static int init_common(void)
 	git_win32__stack_init();
 #endif
 
-	/* Initialize any other subsystems that have global state */
-	if ((ret = git_hash_global_init()) == 0 &&
-		(ret = git_sysdir_global_init()) == 0 &&
-		(ret = git_filter_global_init()) == 0 &&
-		(ret = git_merge_driver_global_init()) == 0 &&
-		(ret = git_transport_ssh_global_init()) == 0 &&
-		(ret = git_openssl_stream_global_init()) == 0 &&
-		(ret = git_curl_stream_global_init()) == 0)
-		ret = git_mwindow_global_init();
+	/* 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;
 
@@ -129,14 +141,21 @@ static void shutdown_common(void)
  */
 #if defined(GIT_THREADS) && defined(GIT_WIN32)
 
-static DWORD _tls_index;
+static DWORD _fls_index;
 static volatile LONG _mutex = 0;
 
+static void WINAPI fls_free(void *st)
+{
+	git__global_state_cleanup(st);
+	git__free(st);
+}
+
 static int synchronized_threads_init(void)
 {
 	int error;
 
-	_tls_index = TlsAlloc();
+	if ((_fls_index = FlsAlloc(fls_free)) == FLS_OUT_OF_INDEXES)
+		return -1;
 
 	git_threads_init();
 
@@ -178,9 +197,7 @@ int git_libgit2_shutdown(void)
 	if ((ret = git_atomic_dec(&git__n_inits)) == 0) {
 		shutdown_common();
 
-		git__free_tls_data();
-
-		TlsFree(_tls_index);
+		FlsFree(_fls_index);
 		git_mutex_free(&git__mwindow_mutex);
 
 #if defined(GIT_MSVC_CRTDBG)
@@ -201,7 +218,7 @@ git_global_st *git__global_state(void)
 
 	assert(git_atomic_get(&git__n_inits) > 0);
 
-	if ((ptr = TlsGetValue(_tls_index)) != NULL)
+	if ((ptr = FlsGetValue(_fls_index)) != NULL)
 		return ptr;
 
 	ptr = git__calloc(1, sizeof(git_global_st));
@@ -210,43 +227,10 @@ git_global_st *git__global_state(void)
 
 	git_buf_init(&ptr->error_buf, 0);
 
-	TlsSetValue(_tls_index, ptr);
+	FlsSetValue(_fls_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;
@@ -274,10 +258,10 @@ int git_libgit2_init(void)
 {
 	int ret, err;
 
-	ret = git_atomic_inc(&git__n_inits);
-
 	if ((err = pthread_mutex_lock(&_init_mutex)) != 0)
 		return err;
+
+	ret = git_atomic_inc(&git__n_inits);
 	err = pthread_once(&_once_init, init_once);
 	err |= pthread_mutex_unlock(&_init_mutex);
 
@@ -291,13 +275,13 @@ int git_libgit2_shutdown(void)
 {
 	void *ptr = NULL;
 	pthread_once_t new_once = PTHREAD_ONCE_INIT;
-	int ret;
+	int error, ret;
 
-	if ((ret = git_atomic_dec(&git__n_inits)) != 0)
-		return ret;
+	if ((error = pthread_mutex_lock(&_init_mutex)) != 0)
+		return error;
 
-	if ((ret = pthread_mutex_lock(&_init_mutex)) != 0)
-		return ret;
+	if ((ret = git_atomic_dec(&git__n_inits)) != 0)
+		goto out;
 
 	/* Shut down any subsystems that have global state */
 	shutdown_common();
@@ -312,10 +296,11 @@ int git_libgit2_shutdown(void)
 	git_mutex_free(&git__mwindow_mutex);
 	_once_init = new_once;
 
-	if ((ret = pthread_mutex_unlock(&_init_mutex)) != 0)
-		return ret;
+out:
+	if ((error = pthread_mutex_unlock(&_init_mutex)) != 0)
+		return error;
 
-	return 0;
+	return ret;
 }
 
 git_global_st *git__global_state(void)

data/vendor/libgit2/src/global.h

@@ -35,8 +35,6 @@ 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);
 

data/vendor/libgit2/src/hash.c

@@ -7,6 +7,67 @@
 
 #include "hash.h"
 
+int git_hash_global_init(void)
+{
+	return git_hash_sha1_global_init();
+}
+
+int git_hash_ctx_init(git_hash_ctx *ctx)
+{
+	int error;
+
+	if ((error = git_hash_sha1_ctx_init(&ctx->sha1)) < 0)
+		return error;
+
+	ctx->algo = GIT_HASH_ALGO_SHA1;
+
+	return 0;
+}
+
+void git_hash_ctx_cleanup(git_hash_ctx *ctx)
+{
+	switch (ctx->algo) {
+		case GIT_HASH_ALGO_SHA1:
+			git_hash_sha1_ctx_cleanup(&ctx->sha1);
+			return;
+		default:
+			assert(0);
+	}
+}
+
+int git_hash_init(git_hash_ctx *ctx)
+{
+	switch (ctx->algo) {
+		case GIT_HASH_ALGO_SHA1:
+			return git_hash_sha1_init(&ctx->sha1);
+		default:
+			assert(0);
+			return -1;
+	}
+}
+
+int git_hash_update(git_hash_ctx *ctx, const void *data, size_t len)
+{
+	switch (ctx->algo) {
+		case GIT_HASH_ALGO_SHA1:
+			return git_hash_sha1_update(&ctx->sha1, data, len);
+		default:
+			assert(0);
+			return -1;
+	}
+}
+
+int git_hash_final(git_oid *out, git_hash_ctx *ctx)
+{
+	switch (ctx->algo) {
+		case GIT_HASH_ALGO_SHA1:
+			return git_hash_sha1_final(out, &ctx->sha1);
+		default:
+			assert(0);
+			return -1;
+	}
+}
+
 int git_hash_buf(git_oid *out, const void *data, size_t len)
 {
 	git_hash_ctx ctx;

data/vendor/libgit2/src/hash.h

@@ -4,6 +4,7 @@
  * 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_h__
 #define INCLUDE_hash_h__
 
@@ -11,30 +12,30 @@
 
 #include "git2/oid.h"
 
-typedef struct git_hash_prov git_hash_prov;
-typedef struct git_hash_ctx git_hash_ctx;
-
-int git_hash_global_init(void);
-int git_hash_ctx_init(git_hash_ctx *ctx);
-void git_hash_ctx_cleanup(git_hash_ctx *ctx);
-
-#if defined(GIT_SHA1_COLLISIONDETECT)
-# include "hash/hash_collisiondetect.h"
-#elif defined(GIT_SHA1_COMMON_CRYPTO)
-# include "hash/hash_common_crypto.h"
-#elif defined(GIT_SHA1_OPENSSL)
-# include "hash/hash_openssl.h"
-#elif defined(GIT_SHA1_WIN32)
-# include "hash/hash_win32.h"
-#else
-# include "hash/hash_generic.h"
-#endif
-
 typedef struct {
 	void *data;
 	size_t len;
 } git_buf_vec;
 
+typedef enum {
+	GIT_HASH_ALGO_UNKNOWN = 0,
+	GIT_HASH_ALGO_SHA1,
+} git_hash_algo_t;
+
+#include "hash/sha1.h"
+
+typedef struct git_hash_ctx {
+	union {
+		git_hash_sha1_ctx sha1;
+	};
+	git_hash_algo_t algo;
+} git_hash_ctx;
+
+int git_hash_global_init(void);
+
+int git_hash_ctx_init(git_hash_ctx *ctx);
+void git_hash_ctx_cleanup(git_hash_ctx *ctx);
+
 int git_hash_init(git_hash_ctx *c);
 int git_hash_update(git_hash_ctx *c, const void *data, size_t len);
 int git_hash_final(git_oid *out, git_hash_ctx *c);

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

@@ -0,0 +1,38 @@
+/*
+ * 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_sha1_h__
+#define INCLUDE_hash_sha1_h__
+
+#include "common.h"
+
+typedef struct git_hash_sha1_ctx git_hash_sha1_ctx;
+
+#if defined(GIT_SHA1_COLLISIONDETECT)
+# include "sha1/collisiondetect.h"
+#elif defined(GIT_SHA1_COMMON_CRYPTO)
+# include "sha1/common_crypto.h"
+#elif defined(GIT_SHA1_OPENSSL)
+# include "sha1/openssl.h"
+#elif defined(GIT_SHA1_WIN32)
+# include "sha1/win32.h"
+#elif defined(GIT_SHA1_MBEDTLS)
+# include "sha1/mbedtls.h"
+#else
+# include "sha1/generic.h"
+#endif
+
+int git_hash_sha1_global_init(void);
+
+int git_hash_sha1_ctx_init(git_hash_sha1_ctx *ctx);
+void git_hash_sha1_ctx_cleanup(git_hash_sha1_ctx *ctx);
+
+int git_hash_sha1_init(git_hash_sha1_ctx *c);
+int git_hash_sha1_update(git_hash_sha1_ctx *c, const void *data, size_t len);
+int git_hash_sha1_final(git_oid *out, git_hash_sha1_ctx *c);
+
+#endif

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

@@ -0,0 +1,48 @@
+/*
+ * 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 "collisiondetect.h"
+
+int git_hash_sha1_global_init(void)
+{
+	return 0;
+}
+
+int git_hash_sha1_ctx_init(git_hash_sha1_ctx *ctx)
+{
+	return git_hash_sha1_init(ctx);
+}
+
+void git_hash_sha1_ctx_cleanup(git_hash_sha1_ctx *ctx)
+{
+	GIT_UNUSED(ctx);
+}
+
+int git_hash_sha1_init(git_hash_sha1_ctx *ctx)
+{
+	assert(ctx);
+	SHA1DCInit(&ctx->c);
+	return 0;
+}
+
+int git_hash_sha1_update(git_hash_sha1_ctx *ctx, const void *data, size_t len)
+{
+	assert(ctx);
+	SHA1DCUpdate(&ctx->c, data, len);
+	return 0;
+}
+
+int git_hash_sha1_final(git_oid *out, git_hash_sha1_ctx *ctx)
+{
+	assert(ctx);
+	if (SHA1DCFinal(out->id, &ctx->c)) {
+		git_error_set(GIT_ERROR_SHA1, "SHA1 collision attack detected");
+		return -1;
+	}
+
+	return 0;
+}