rugged 0.28.4 → 0.28.4.1

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

@@ -5,15 +5,25 @@
  * a Linking Exception. For full terms see the included COPYING file.
  */
 
-#ifndef INCLUDE_hash_sha1_generic_h__
-#define INCLUDE_hash_sha1_generic_h__
+#ifndef INCLUDE_hash_hash_generic_h__
+#define INCLUDE_hash_hash_generic_h__
 
-#include "hash/sha1.h"
+#include "common.h"
 
-struct git_hash_sha1_ctx {
+#include "hash.h"
+
+struct git_hash_ctx {
 	unsigned long long size;
 	unsigned int H[5];
 	unsigned int W[16];
 };
 
+#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;
+}
+
 #endif

data/vendor/libgit2/src/hash/{sha1/mbedtls.c → hash_mbedtls.c}

@@ -5,25 +5,17 @@
  * a Linking Exception. For full terms see the included COPYING file.
  */
 
-#include "mbedtls.h"
+#include "common.h"
+#include "hash.h"
+#include "hash/hash_mbedtls.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)
+void git_hash_ctx_cleanup(git_hash_ctx *ctx)
 {
     assert(ctx);
     mbedtls_sha1_free(&ctx->c);
 }
 
-int git_hash_sha1_init(git_hash_sha1_ctx *ctx)
+int git_hash_init(git_hash_ctx *ctx)
 {
     assert(ctx);
     mbedtls_sha1_init(&ctx->c);
@@ -31,14 +23,14 @@ 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)
 {
     assert(ctx);
     mbedtls_sha1_update(&ctx->c, data, 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)
 {
     assert(ctx);
     mbedtls_sha1_finish(&ctx->c, out->id);

data/vendor/libgit2/src/hash/{sha1/mbedtls.h → hash_mbedtls.h}

@@ -5,15 +5,20 @@
  * a Linking Exception. For full terms see the included COPYING file.
  */
 
-#ifndef INCLUDE_hash_sha1_mbedtls_h__
-#define INCLUDE_hash_sha1_mbedtls_h__
-
-#include "hash/sha1.h"
+#ifndef INCLUDE_hash_mbedtld_h__
+#define INCLUDE_hash_mbedtld_h__
 
 #include <mbedtls/sha1.h>
 
-struct git_hash_sha1_ctx {
+struct git_hash_ctx {
     mbedtls_sha1_context c;
 };
 
-#endif /* INCLUDE_hash_sha1_mbedtls_h__ */
+#define git_hash_ctx_init(ctx) git_hash_init(ctx)
+
+GIT_INLINE(int) git_hash_global_init(void)
+{
+	return 0;
+}
+
+#endif /* INCLUDE_hash_mbedtld_h__ */

data/vendor/libgit2/src/hash/{sha1/openssl.c → hash_openssl.h}

@@ -5,24 +5,26 @@
  * a Linking Exception. For full terms see the included COPYING file.
  */
 
-#include "openssl.h"
+#ifndef INCLUDE_hash_hash_openssl_h__
+#define INCLUDE_hash_hash_openssl_h__
 
-int git_hash_sha1_global_init(void)
-{
-	return 0;
-}
+#include "hash.h"
 
-int git_hash_sha1_ctx_init(git_hash_sha1_ctx *ctx)
-{
-	return git_hash_sha1_init(ctx);
-}
+#include <openssl/sha.h>
 
-void git_hash_sha1_ctx_cleanup(git_hash_sha1_ctx *ctx)
+struct git_hash_ctx {
+	SHA_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)
 {
-	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);
 
@@ -34,7 +36,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)
+GIT_INLINE(int) git_hash_update(git_hash_ctx *ctx, const void *data, size_t len)
 {
 	assert(ctx);
 
@@ -46,7 +48,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)
+GIT_INLINE(int) git_hash_final(git_oid *out, git_hash_ctx *ctx)
 {
 	assert(ctx);
 
@@ -57,3 +59,5 @@ int git_hash_sha1_final(git_oid *out, git_hash_sha1_ctx *ctx)
 
 	return 0;
 }
+
+#endif

data/vendor/libgit2/src/hash/{sha1/win32.c → hash_win32.c}

@@ -5,25 +5,15 @@
  * a Linking Exception. For full terms see the included COPYING file.
  */
 
-#include "win32.h"
+#include "hash_win32.h"
 
 #include "global.h"
+#include "hash.h"
 
 #include <wincrypt.h>
 #include <strsafe.h>
 
-#define GIT_HASH_CNG_DLL_NAME           "bcrypt.dll"
-
-/* BCRYPT_SHA1_ALGORITHM */
-#define GIT_HASH_CNG_HASH_TYPE          L"SHA1"
-
-/* BCRYPT_OBJECT_LENGTH */
-#define GIT_HASH_CNG_HASH_OBJECT_LEN    L"ObjectLength"
-
-/* BCRYPT_HASH_REUSEABLE_FLAGS */
-#define GIT_HASH_CNG_HASH_REUSABLE      0x00000020
-
-static git_hash_prov hash_prov = {0};
+static struct git_hash_prov hash_prov = {0};
 
 /* Hash initialization */
 
@@ -111,7 +101,7 @@ GIT_INLINE(void) hash_cryptoapi_prov_shutdown(void)
 	hash_prov.type = INVALID;
 }
 
-static void sha1_shutdown(void)
+static void git_hash_global_shutdown(void)
 {
 	if (hash_prov.type == CNG)
 		hash_cng_prov_shutdown();
@@ -119,7 +109,7 @@ static void sha1_shutdown(void)
 		hash_cryptoapi_prov_shutdown();
 }
 
-int git_hash_sha1_global_init(void)
+int git_hash_global_init(void)
 {
 	int error = 0;
 
@@ -129,22 +119,22 @@ int git_hash_sha1_global_init(void)
 	if ((error = hash_cng_prov_init()) < 0)
 		error = hash_cryptoapi_prov_init();
 
-	git__on_shutdown(sha1_shutdown);
+	git__on_shutdown(git_hash_global_shutdown);
 
 	return error;
 }
 
 /* CryptoAPI: available in Windows XP and newer */
 
-GIT_INLINE(int) hash_ctx_cryptoapi_init(git_hash_sha1_ctx *ctx)
+GIT_INLINE(int) hash_ctx_cryptoapi_init(git_hash_ctx *ctx)
 {
 	ctx->type = CRYPTOAPI;
 	ctx->prov = &hash_prov;
 
-	return git_hash_sha1_init(ctx);
+	return git_hash_init(ctx);
 }
 
-GIT_INLINE(int) hash_cryptoapi_init(git_hash_sha1_ctx *ctx)
+GIT_INLINE(int) hash_cryptoapi_init(git_hash_ctx *ctx)
 {
 	if (ctx->ctx.cryptoapi.valid)
 		CryptDestroyHash(ctx->ctx.cryptoapi.hash_handle);
@@ -159,7 +149,7 @@ GIT_INLINE(int) hash_cryptoapi_init(git_hash_sha1_ctx *ctx)
 	return 0;
 }
 
-GIT_INLINE(int) hash_cryptoapi_update(git_hash_sha1_ctx *ctx, const void *_data, size_t len)
+GIT_INLINE(int) hash_cryptoapi_update(git_hash_ctx *ctx, const void *_data, size_t len)
 {
 	const BYTE *data = (BYTE *)_data;
 
@@ -180,7 +170,7 @@ GIT_INLINE(int) hash_cryptoapi_update(git_hash_sha1_ctx *ctx, const void *_data,
 	return 0;
 }
 
-GIT_INLINE(int) hash_cryptoapi_final(git_oid *out, git_hash_sha1_ctx *ctx)
+GIT_INLINE(int) hash_cryptoapi_final(git_oid *out, git_hash_ctx *ctx)
 {
 	DWORD len = 20;
 	int error = 0;
@@ -198,7 +188,7 @@ GIT_INLINE(int) hash_cryptoapi_final(git_oid *out, git_hash_sha1_ctx *ctx)
 	return error;
 }
 
-GIT_INLINE(void) hash_ctx_cryptoapi_cleanup(git_hash_sha1_ctx *ctx)
+GIT_INLINE(void) hash_ctx_cryptoapi_cleanup(git_hash_ctx *ctx)
 {
 	if (ctx->ctx.cryptoapi.valid)
 		CryptDestroyHash(ctx->ctx.cryptoapi.hash_handle);
@@ -206,7 +196,7 @@ GIT_INLINE(void) hash_ctx_cryptoapi_cleanup(git_hash_sha1_ctx *ctx)
 
 /* CNG: Available in Windows Server 2008 and newer */
 
-GIT_INLINE(int) hash_ctx_cng_init(git_hash_sha1_ctx *ctx)
+GIT_INLINE(int) hash_ctx_cng_init(git_hash_ctx *ctx)
 {
 	if ((ctx->ctx.cng.hash_object = git__malloc(hash_prov.prov.cng.hash_object_size)) == NULL)
 		return -1;
@@ -224,7 +214,7 @@ GIT_INLINE(int) hash_ctx_cng_init(git_hash_sha1_ctx *ctx)
 	return 0;
 }
 
-GIT_INLINE(int) hash_cng_init(git_hash_sha1_ctx *ctx)
+GIT_INLINE(int) hash_cng_init(git_hash_ctx *ctx)
 {
 	BYTE hash[GIT_OID_RAWSZ];
 
@@ -242,7 +232,7 @@ GIT_INLINE(int) hash_cng_init(git_hash_sha1_ctx *ctx)
 	return 0;
 }
 
-GIT_INLINE(int) hash_cng_update(git_hash_sha1_ctx *ctx, const void *_data, size_t len)
+GIT_INLINE(int) hash_cng_update(git_hash_ctx *ctx, const void *_data, size_t len)
 {
 	PBYTE data = (PBYTE)_data;
 
@@ -261,7 +251,7 @@ GIT_INLINE(int) hash_cng_update(git_hash_sha1_ctx *ctx, const void *_data, size_
 	return 0;
 }
 
-GIT_INLINE(int) hash_cng_final(git_oid *out, git_hash_sha1_ctx *ctx)
+GIT_INLINE(int) hash_cng_final(git_oid *out, git_hash_ctx *ctx)
 {
 	if (ctx->prov->prov.cng.finish_hash(ctx->ctx.cng.hash_handle, out->id, GIT_OID_RAWSZ, 0) < 0) {
 		git_error_set(GIT_ERROR_OS, "hash could not be finished");
@@ -273,7 +263,7 @@ GIT_INLINE(int) hash_cng_final(git_oid *out, git_hash_sha1_ctx *ctx)
 	return 0;
 }
 
-GIT_INLINE(void) hash_ctx_cng_cleanup(git_hash_sha1_ctx *ctx)
+GIT_INLINE(void) hash_ctx_cng_cleanup(git_hash_ctx *ctx)
 {
 	ctx->prov->prov.cng.destroy_hash(ctx->ctx.cng.hash_handle);
 	git__free(ctx->ctx.cng.hash_object);
@@ -281,7 +271,7 @@ GIT_INLINE(void) hash_ctx_cng_cleanup(git_hash_sha1_ctx *ctx)
 
 /* Indirection between CryptoAPI and CNG */
 
-int git_hash_sha1_ctx_init(git_hash_sha1_ctx *ctx)
+int git_hash_ctx_init(git_hash_ctx *ctx)
 {
 	int error = 0;
 
@@ -292,33 +282,33 @@ int git_hash_sha1_ctx_init(git_hash_sha1_ctx *ctx)
 	 * initialized with git_libgit2_init.  Otherwise, it must be initialized
 	 * at first use.
 	 */
-	if (hash_prov.type == INVALID && (error = git_hash_sha1_global_init()) < 0)
+	if (hash_prov.type == INVALID && (error = git_hash_global_init()) < 0)
 		return error;
 
-	memset(ctx, 0x0, sizeof(git_hash_sha1_ctx));
+	memset(ctx, 0x0, sizeof(git_hash_ctx));
 
 	return (hash_prov.type == CNG) ? hash_ctx_cng_init(ctx) : hash_ctx_cryptoapi_init(ctx);
 }
 
-int git_hash_sha1_init(git_hash_sha1_ctx *ctx)
+int git_hash_init(git_hash_ctx *ctx)
 {
 	assert(ctx && 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)
+int git_hash_update(git_hash_ctx *ctx, const void *data, size_t len)
 {
 	assert(ctx && 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)
+int git_hash_final(git_oid *out, git_hash_ctx *ctx)
 {
 	assert(ctx && 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)
+void git_hash_ctx_cleanup(git_hash_ctx *ctx)
 {
 	assert(ctx);
 

data/vendor/libgit2/src/hash/{sha1/win32.h → hash_win32.h}

@@ -5,10 +5,12 @@
  * a Linking Exception. For full terms see the included COPYING file.
  */
 
-#ifndef INCLUDE_hash_sha1_win32_h__
-#define INCLUDE_hash_sha1_win32_h__
+#ifndef INCLUDE_hash_hash_win32_h__
+#define INCLUDE_hash_hash_win32_h__
 
-#include "hash/sha1.h"
+#include "common.h"
+
+#include "hash.h"
 
 #include <wincrypt.h>
 #include <strsafe.h>
@@ -34,6 +36,17 @@ struct hash_cryptoapi_prov {
  * would not exist when building in pre-Windows 2008 environments.
  */
 
+#define GIT_HASH_CNG_DLL_NAME           "bcrypt.dll"
+
+/* BCRYPT_SHA1_ALGORITHM */
+#define GIT_HASH_CNG_HASH_TYPE          L"SHA1"
+
+/* BCRYPT_OBJECT_LENGTH */
+#define GIT_HASH_CNG_HASH_OBJECT_LEN    L"ObjectLength"
+
+/* BCRYPT_HASH_REUSEABLE_FLAGS */
+#define GIT_HASH_CNG_HASH_REUSABLE      0x00000020
+
 /* Function declarations for CNG */
 typedef NTSTATUS (WINAPI *hash_win32_cng_open_algorithm_provider_fn)(
 	HANDLE /* BCRYPT_ALG_HANDLE */ *phAlgorithm,
@@ -93,14 +106,14 @@ struct hash_cng_prov {
 	DWORD hash_object_size;
 };
 
-typedef struct {
+struct git_hash_prov {
 	enum hash_win32_prov_type type;
 
 	union {
 		struct hash_cryptoapi_prov cryptoapi;
 		struct hash_cng_prov cng;
 	} prov;
-} git_hash_prov;
+};
 
 /* Hash contexts */
 
@@ -115,7 +128,7 @@ struct hash_cng_ctx {
 	PBYTE hash_object;
 };
 
-struct git_hash_sha1_ctx {
+struct git_hash_ctx {
 	enum hash_win32_prov_type type;
 	git_hash_prov *prov;
 

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

@@ -93,23 +93,13 @@
 #define SHA1DC_BIGENDIAN
 
 /* Not under GCC-alike or glibc or *BSD or newlib or <processor whitelist> */
-#elif (defined(_AIX) || defined(__hpux))
-
-/*
- * Defines Big Endian on a whitelist of OSs that are known to be Big
- * Endian-only. See
- * https://public-inbox.org/git/93056823-2740-d072-1ebd-46b440b33d7e@felt.demon.nl/
- */
-#define SHA1DC_BIGENDIAN
-
-/* Not under GCC-alike or glibc or *BSD or newlib or <processor whitelist> or <os whitelist> */
 #elif defined(SHA1DC_ON_INTEL_LIKE_PROCESSOR)
 /*
  * As a last resort before we do anything else we're not 100% sure
  * about below, we blacklist specific processors here. We could add
  * more, see e.g. https://wiki.debian.org/ArchitectureSpecificsMemo
  */
-#else /* Not under GCC-alike or glibc or *BSD or newlib or <processor whitelist> or <os whitelist> or <processor blacklist> */
+#else /* Not under GCC-alike or glibc or *BSD or newlib or <processor whitelist>  or <processor blacklist> */
 
 /* We do nothing more here for now */
 /*#error "Uncomment this to see if you fall through all the detection"*/
@@ -124,11 +114,10 @@
 #endif
 /*ENDIANNESS SELECTION*/
 
-#ifndef SHA1DC_FORCE_ALIGNED_ACCESS
 #if defined(SHA1DC_FORCE_UNALIGNED_ACCESS) || defined(SHA1DC_ON_INTEL_LIKE_PROCESSOR)
 #define SHA1DC_ALLOW_UNALIGNED_ACCESS
-#endif /*UNALIGNED ACCESS DETECTION*/
-#endif /*FORCE ALIGNED ACCESS*/
+#endif /*UNALIGNMENT DETECTION*/
+
 
 #define rotate_right(x,n) (((x)>>(n))|((x)<<(32-(n))))
 #define rotate_left(x,n)  (((x)<<(n))|((x)>>(32-(n))))