rugged 0.28.4 → 0.28.4.1

data/vendor/libgit2/src/fnmatch.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+#ifndef INCLUDE_fnmatch_h__
+#define INCLUDE_fnmatch_h__
+
+#include "common.h"
+
+#define FNM_NOMATCH		1		/* Match failed. */
+#define FNM_NOSYS		2		/* Function not supported (unused). */
+#define	FNM_NORES		3		/* Out of resources */
+
+#define FNM_NOESCAPE	0x01		/* Disable backslash escaping. */
+#define FNM_PATHNAME	0x02		/* Slash must be matched by slash. */
+#define FNM_PERIOD		0x04		/* Period must be matched by period. */
+#define FNM_LEADING_DIR 0x08		/* Ignore /<tail> after Imatch. */
+#define FNM_CASEFOLD	0x10		/* Case insensitive search. */
+
+#define FNM_IGNORECASE	FNM_CASEFOLD
+#define FNM_FILE_NAME	FNM_PATHNAME
+
+extern int p_fnmatch(const char *pattern, const char *string, int flags);
+
+#endif

data/vendor/libgit2/src/global.c

@@ -141,21 +141,14 @@ static void shutdown_common(void)
  */
 #if defined(GIT_THREADS) && defined(GIT_WIN32)
 
-static DWORD _fls_index;
+static DWORD _tls_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;
 
-	if ((_fls_index = FlsAlloc(fls_free)) == FLS_OUT_OF_INDEXES)
-		return -1;
+	_tls_index = TlsAlloc();
 
 	git_threads_init();
 
@@ -197,7 +190,9 @@ int git_libgit2_shutdown(void)
 	if ((ret = git_atomic_dec(&git__n_inits)) == 0) {
 		shutdown_common();
 
-		FlsFree(_fls_index);
+		git__free_tls_data();
+
+		TlsFree(_tls_index);
 		git_mutex_free(&git__mwindow_mutex);
 
 #if defined(GIT_MSVC_CRTDBG)
@@ -218,7 +213,7 @@ git_global_st *git__global_state(void)
 
 	assert(git_atomic_get(&git__n_inits) > 0);
 
-	if ((ptr = FlsGetValue(_fls_index)) != NULL)
+	if ((ptr = TlsGetValue(_tls_index)) != NULL)
 		return ptr;
 
 	ptr = git__calloc(1, sizeof(git_global_st));
@@ -227,10 +222,43 @@ git_global_st *git__global_state(void)
 
 	git_buf_init(&ptr->error_buf, 0);
 
-	FlsSetValue(_fls_index, ptr);
+	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;

data/vendor/libgit2/src/global.h

@@ -35,6 +35,8 @@ 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,67 +7,6 @@
 
 #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,7 +4,6 @@
  * 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__
 
@@ -12,29 +11,32 @@
 
 #include "git2/oid.h"
 
-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;
+typedef struct git_hash_prov git_hash_prov;
+typedef struct git_hash_ctx git_hash_ctx;
 
-#include "hash/sha1.h"
+int git_hash_ctx_init(git_hash_ctx *ctx);
+void git_hash_ctx_cleanup(git_hash_ctx *ctx);
 
-typedef struct git_hash_ctx {
-	union {
-		git_hash_sha1_ctx sha1;
-	};
-	git_hash_algo_t algo;
-} git_hash_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"
+#elif defined(GIT_SHA1_MBEDTLS)
+# include "hash/hash_mbedtls.h"
+#else
+# include "hash/hash_generic.h"
+#endif
 
 int git_hash_global_init(void);
 
-int git_hash_ctx_init(git_hash_ctx *ctx);
-void git_hash_ctx_cleanup(git_hash_ctx *ctx);
+typedef struct {
+	void *data;
+	size_t len;
+} git_buf_vec;
 
 int git_hash_init(git_hash_ctx *c);
 int git_hash_update(git_hash_ctx *c, const void *data, size_t len);

data/vendor/libgit2/src/hash/{sha1/collisiondetect.c → hash_collisiondetect.h}

@@ -5,38 +5,39 @@
  * a Linking Exception. For full terms see the included COPYING file.
  */
 
-#include "collisiondetect.h"
+#ifndef INCLUDE_hash_hash_collisiondetect_h__
+#define INCLUDE_hash_hash_collisiondetect_h__
 
-int git_hash_sha1_global_init(void)
-{
-	return 0;
-}
+#include "hash.h"
+#include "sha1dc/sha1.h"
 
-int git_hash_sha1_ctx_init(git_hash_sha1_ctx *ctx)
-{
-	return git_hash_sha1_init(ctx);
-}
+struct git_hash_ctx {
+	SHA1_CTX c;
+};
+
+#define git_hash_ctx_init(ctx) git_hash_init(ctx)
+#define git_hash_ctx_cleanup(ctx)
 
-void git_hash_sha1_ctx_cleanup(git_hash_sha1_ctx *ctx)
+GIT_INLINE(int) git_hash_global_init(void)
 {
-	GIT_UNUSED(ctx);
+	return 0;
 }
 
-int git_hash_sha1_init(git_hash_sha1_ctx *ctx)
+GIT_INLINE(int) git_hash_init(git_hash_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)
+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;
 }
 
-int git_hash_sha1_final(git_oid *out, git_hash_sha1_ctx *ctx)
+GIT_INLINE(int) git_hash_final(git_oid *out, git_hash_ctx *ctx)
 {
 	assert(ctx);
 	if (SHA1DCFinal(out->id, &ctx->c)) {
@@ -46,3 +47,5 @@ int git_hash_sha1_final(git_oid *out, git_hash_sha1_ctx *ctx)
 
 	return 0;
 }
+
+#endif

data/vendor/libgit2/src/hash/{sha1/common_crypto.c → hash_common_crypto.h}

@@ -5,33 +5,35 @@
  * a Linking Exception. For full terms see the included COPYING file.
  */
 
-#include "common_crypto.h"
+#ifndef INCLUDE_hash_hash_common_crypto_h__
+#define INCLUDE_hash_hash_common_crypto_h__
 
-#define CC_LONG_MAX ((CC_LONG)-1)
+#include "hash.h"
 
-int git_hash_sha1_global_init(void)
-{
-	return 0;
-}
+#include <CommonCrypto/CommonDigest.h>
 
-int git_hash_sha1_ctx_init(git_hash_sha1_ctx *ctx)
-{
-	return git_hash_sha1_init(ctx);
-}
+struct git_hash_ctx {
+	CC_SHA1_CTX c;
+};
 
-void git_hash_sha1_ctx_cleanup(git_hash_sha1_ctx *ctx)
+#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)
 {
-	GIT_UNUSED(ctx);
+	return 0;
 }
 
-int git_hash_sha1_init(git_hash_sha1_ctx *ctx)
+GIT_INLINE(int) git_hash_init(git_hash_ctx *ctx)
 {
 	assert(ctx);
 	CC_SHA1_Init(&ctx->c);
 	return 0;
 }
 
-int git_hash_sha1_update(git_hash_sha1_ctx *ctx, const void *_data, size_t len)
+GIT_INLINE(int) git_hash_update(git_hash_ctx *ctx, const void *_data, size_t len)
 {
 	const unsigned char *data = _data;
 
@@ -49,9 +51,11 @@ int git_hash_sha1_update(git_hash_sha1_ctx *ctx, const void *_data, size_t len)
 	return 0;
 }
 
-int git_hash_sha1_final(git_oid *out, git_hash_sha1_ctx *ctx)
+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

data/vendor/libgit2/src/hash/{sha1/generic.c → hash_generic.c}

@@ -5,7 +5,9 @@
  * a Linking Exception. For full terms see the included COPYING file.
  */
 
-#include "generic.h"
+#include "hash_generic.h"
+
+#include "hash.h"
 
 #if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
 
@@ -111,7 +113,7 @@
 #define T_40_59(t, A, B, C, D, E) SHA_ROUND(t, SHA_MIX, ((B&C)+(D&(B^C))) , 0x8f1bbcdc, A, B, C, D, E )
 #define T_60_79(t, A, B, C, D, E) SHA_ROUND(t, SHA_MIX, (B^C^D) , 0xca62c1d6, A, B, C, D, E )
 
-static void hash__block(git_hash_sha1_ctx *ctx, const unsigned int *data)
+static void hash__block(git_hash_ctx *ctx, const unsigned int *data)
 {
 	unsigned int A,B,C,D,E;
 	unsigned int array[16];
@@ -219,22 +221,7 @@ static void hash__block(git_hash_sha1_ctx *ctx, const unsigned int *data)
 	ctx->H[4] += E;
 }
 
-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)
+int git_hash_init(git_hash_ctx *ctx)
 {
 	ctx->size = 0;
 
@@ -248,7 +235,7 @@ int git_hash_sha1_init(git_hash_sha1_ctx *ctx)
 	return 0;
 }
 
-int git_hash_sha1_update(git_hash_sha1_ctx *ctx, const void *data, size_t len)
+int git_hash_update(git_hash_ctx *ctx, const void *data, size_t len)
 {
 	unsigned int lenW = ctx->size & 63;
 
@@ -278,7 +265,7 @@ int git_hash_sha1_update(git_hash_sha1_ctx *ctx, const void *data, size_t len)
 	return 0;
 }
 
-int git_hash_sha1_final(git_oid *out, git_hash_sha1_ctx *ctx)
+int git_hash_final(git_oid *out, git_hash_ctx *ctx)
 {
 	static const unsigned char pad[64] = { 0x80 };
 	unsigned int padlen[2];
@@ -289,8 +276,8 @@ int git_hash_sha1_final(git_oid *out, git_hash_sha1_ctx *ctx)
 	padlen[1] = htonl((uint32_t)(ctx->size << 3));
 
 	i = ctx->size & 63;
-	git_hash_sha1_update(ctx, pad, 1+ (63 & (55 - i)));
-	git_hash_sha1_update(ctx, padlen, 8);
+	git_hash_update(ctx, pad, 1+ (63 & (55 - i)));
+	git_hash_update(ctx, padlen, 8);
 
 	/* Output hash */
 	for (i = 0; i < 5; i++)
@@ -298,3 +285,4 @@ int git_hash_sha1_final(git_oid *out, git_hash_sha1_ctx *ctx)
 
 	return 0;
 }
+