rugged 0.27.7 → 0.27.10

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

@@ -5,15 +5,25 @@
  * a Linking Exception. For full terms see the included COPYING file.
  */
 
-#include "hash_win32.h"
+#include "win32.h"
 
 #include "global.h"
-#include "hash.h"
 
 #include <wincrypt.h>
 #include <strsafe.h>
 
-static struct git_hash_prov hash_prov = {0};
+#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};
 
 /* Hash initialization */
 
@@ -25,7 +35,7 @@ GIT_INLINE(int) hash_cng_prov_init(void)
 
 	/* Only use CNG on Windows 2008 / Vista SP1  or better (Windows 6.0 SP1) */
 	if (!git_has_win32_version(6, 0, 1)) {
-		giterr_set(GITERR_SHA1, "CryptoNG is not supported on this platform");
+		git_error_set(GIT_ERROR_SHA1, "CryptoNG is not supported on this platform");
 		return -1;
 	}
 
@@ -35,7 +45,7 @@ GIT_INLINE(int) hash_cng_prov_init(void)
 		StringCchCat(dll_path, MAX_PATH, "\\") < 0 ||
 		StringCchCat(dll_path, MAX_PATH, GIT_HASH_CNG_DLL_NAME) < 0 ||
 		(hash_prov.prov.cng.dll = LoadLibrary(dll_path)) == NULL) {
-		giterr_set(GITERR_SHA1, "CryptoNG library could not be loaded");
+		git_error_set(GIT_ERROR_SHA1, "CryptoNG library could not be loaded");
 		return -1;
 	}
 
@@ -49,7 +59,7 @@ GIT_INLINE(int) hash_cng_prov_init(void)
 		(hash_prov.prov.cng.close_algorithm_provider = (hash_win32_cng_close_algorithm_provider_fn)GetProcAddress(hash_prov.prov.cng.dll, "BCryptCloseAlgorithmProvider")) == NULL) {
 		FreeLibrary(hash_prov.prov.cng.dll);
 
-		giterr_set(GITERR_OS, "CryptoNG functions could not be loaded");
+		git_error_set(GIT_ERROR_OS, "CryptoNG functions could not be loaded");
 		return -1;
 	}
 
@@ -57,7 +67,7 @@ GIT_INLINE(int) hash_cng_prov_init(void)
 	if (hash_prov.prov.cng.open_algorithm_provider(&hash_prov.prov.cng.handle, GIT_HASH_CNG_HASH_TYPE, NULL, GIT_HASH_CNG_HASH_REUSABLE) < 0) {
 		FreeLibrary(hash_prov.prov.cng.dll);
 
-		giterr_set(GITERR_OS, "algorithm provider could not be initialized");
+		git_error_set(GIT_ERROR_OS, "algorithm provider could not be initialized");
 		return -1;
 	}
 
@@ -66,7 +76,7 @@ GIT_INLINE(int) hash_cng_prov_init(void)
 		hash_prov.prov.cng.close_algorithm_provider(hash_prov.prov.cng.handle, 0);
 		FreeLibrary(hash_prov.prov.cng.dll);
 
-		giterr_set(GITERR_OS, "algorithm handle could not be found");
+		git_error_set(GIT_ERROR_OS, "algorithm handle could not be found");
 		return -1;
 	}
 
@@ -86,7 +96,7 @@ GIT_INLINE(void) hash_cng_prov_shutdown(void)
 GIT_INLINE(int) hash_cryptoapi_prov_init()
 {
 	if (!CryptAcquireContext(&hash_prov.prov.cryptoapi.handle, NULL, 0, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT)) {
-		giterr_set(GITERR_OS, "legacy hash context could not be started");
+		git_error_set(GIT_ERROR_OS, "legacy hash context could not be started");
 		return -1;
 	}
 
@@ -101,7 +111,7 @@ GIT_INLINE(void) hash_cryptoapi_prov_shutdown(void)
 	hash_prov.type = INVALID;
 }
 
-static void git_hash_global_shutdown(void)
+static void sha1_shutdown(void)
 {
 	if (hash_prov.type == CNG)
 		hash_cng_prov_shutdown();
@@ -109,7 +119,7 @@ static void git_hash_global_shutdown(void)
 		hash_cryptoapi_prov_shutdown();
 }
 
-int git_hash_global_init(void)
+int git_hash_sha1_global_init(void)
 {
 	int error = 0;
 
@@ -119,29 +129,29 @@ int git_hash_global_init(void)
 	if ((error = hash_cng_prov_init()) < 0)
 		error = hash_cryptoapi_prov_init();
 
-	git__on_shutdown(git_hash_global_shutdown);
+	git__on_shutdown(sha1_shutdown);
 
 	return error;
 }
 
 /* CryptoAPI: available in Windows XP and newer */
 
-GIT_INLINE(int) hash_ctx_cryptoapi_init(git_hash_ctx *ctx)
+GIT_INLINE(int) hash_ctx_cryptoapi_init(git_hash_sha1_ctx *ctx)
 {
 	ctx->type = CRYPTOAPI;
 	ctx->prov = &hash_prov;
 
-	return git_hash_init(ctx);
+	return git_hash_sha1_init(ctx);
 }
 
-GIT_INLINE(int) hash_cryptoapi_init(git_hash_ctx *ctx)
+GIT_INLINE(int) hash_cryptoapi_init(git_hash_sha1_ctx *ctx)
 {
 	if (ctx->ctx.cryptoapi.valid)
 		CryptDestroyHash(ctx->ctx.cryptoapi.hash_handle);
 
 	if (!CryptCreateHash(ctx->prov->prov.cryptoapi.handle, CALG_SHA1, 0, 0, &ctx->ctx.cryptoapi.hash_handle)) {
 		ctx->ctx.cryptoapi.valid = 0;
-		giterr_set(GITERR_OS, "legacy hash implementation could not be created");
+		git_error_set(GIT_ERROR_OS, "legacy hash implementation could not be created");
 		return -1;
 	}
 
@@ -149,7 +159,7 @@ GIT_INLINE(int) hash_cryptoapi_init(git_hash_ctx *ctx)
 	return 0;
 }
 
-GIT_INLINE(int) hash_cryptoapi_update(git_hash_ctx *ctx, const void *_data, size_t len)
+GIT_INLINE(int) hash_cryptoapi_update(git_hash_sha1_ctx *ctx, const void *_data, size_t len)
 {
 	const BYTE *data = (BYTE *)_data;
 
@@ -159,7 +169,7 @@ GIT_INLINE(int) hash_cryptoapi_update(git_hash_ctx *ctx, const void *_data, size
 		DWORD chunk = (len > MAXDWORD) ? MAXDWORD : (DWORD)len;
 
 		if (!CryptHashData(ctx->ctx.cryptoapi.hash_handle, data, chunk, 0)) {
-			giterr_set(GITERR_OS, "legacy hash data could not be updated");
+			git_error_set(GIT_ERROR_OS, "legacy hash data could not be updated");
 			return -1;
 		}
 
@@ -170,7 +180,7 @@ GIT_INLINE(int) hash_cryptoapi_update(git_hash_ctx *ctx, const void *_data, size
 	return 0;
 }
 
-GIT_INLINE(int) hash_cryptoapi_final(git_oid *out, git_hash_ctx *ctx)
+GIT_INLINE(int) hash_cryptoapi_final(git_oid *out, git_hash_sha1_ctx *ctx)
 {
 	DWORD len = 20;
 	int error = 0;
@@ -178,7 +188,7 @@ GIT_INLINE(int) hash_cryptoapi_final(git_oid *out, git_hash_ctx *ctx)
 	assert(ctx->ctx.cryptoapi.valid);
 
 	if (!CryptGetHashParam(ctx->ctx.cryptoapi.hash_handle, HP_HASHVAL, out->id, &len, 0)) {
-		giterr_set(GITERR_OS, "legacy hash data could not be finished");
+		git_error_set(GIT_ERROR_OS, "legacy hash data could not be finished");
 		error = -1;
 	}
 
@@ -188,7 +198,7 @@ GIT_INLINE(int) hash_cryptoapi_final(git_oid *out, git_hash_ctx *ctx)
 	return error;
 }
 
-GIT_INLINE(void) hash_ctx_cryptoapi_cleanup(git_hash_ctx *ctx)
+GIT_INLINE(void) hash_ctx_cryptoapi_cleanup(git_hash_sha1_ctx *ctx)
 {
 	if (ctx->ctx.cryptoapi.valid)
 		CryptDestroyHash(ctx->ctx.cryptoapi.hash_handle);
@@ -196,7 +206,7 @@ GIT_INLINE(void) hash_ctx_cryptoapi_cleanup(git_hash_ctx *ctx)
 
 /* CNG: Available in Windows Server 2008 and newer */
 
-GIT_INLINE(int) hash_ctx_cng_init(git_hash_ctx *ctx)
+GIT_INLINE(int) hash_ctx_cng_init(git_hash_sha1_ctx *ctx)
 {
 	if ((ctx->ctx.cng.hash_object = git__malloc(hash_prov.prov.cng.hash_object_size)) == NULL)
 		return -1;
@@ -204,7 +214,7 @@ GIT_INLINE(int) hash_ctx_cng_init(git_hash_ctx *ctx)
 	if (hash_prov.prov.cng.create_hash(hash_prov.prov.cng.handle, &ctx->ctx.cng.hash_handle, ctx->ctx.cng.hash_object, hash_prov.prov.cng.hash_object_size, NULL, 0, 0) < 0) {
 		git__free(ctx->ctx.cng.hash_object);
 
-		giterr_set(GITERR_OS, "hash implementation could not be created");
+		git_error_set(GIT_ERROR_OS, "hash implementation could not be created");
 		return -1;
 	}
 
@@ -214,7 +224,7 @@ GIT_INLINE(int) hash_ctx_cng_init(git_hash_ctx *ctx)
 	return 0;
 }
 
-GIT_INLINE(int) hash_cng_init(git_hash_ctx *ctx)
+GIT_INLINE(int) hash_cng_init(git_hash_sha1_ctx *ctx)
 {
 	BYTE hash[GIT_OID_RAWSZ];
 
@@ -223,7 +233,7 @@ GIT_INLINE(int) hash_cng_init(git_hash_ctx *ctx)
 
 	/* CNG needs to be finished to restart */
 	if (ctx->prov->prov.cng.finish_hash(ctx->ctx.cng.hash_handle, hash, GIT_OID_RAWSZ, 0) < 0) {
-		giterr_set(GITERR_OS, "hash implementation could not be finished");
+		git_error_set(GIT_ERROR_OS, "hash implementation could not be finished");
 		return -1;
 	}
 
@@ -232,7 +242,7 @@ GIT_INLINE(int) hash_cng_init(git_hash_ctx *ctx)
 	return 0;
 }
 
-GIT_INLINE(int) hash_cng_update(git_hash_ctx *ctx, const void *_data, size_t len)
+GIT_INLINE(int) hash_cng_update(git_hash_sha1_ctx *ctx, const void *_data, size_t len)
 {
 	PBYTE data = (PBYTE)_data;
 
@@ -240,7 +250,7 @@ GIT_INLINE(int) hash_cng_update(git_hash_ctx *ctx, const void *_data, size_t len
 		ULONG chunk = (len > ULONG_MAX) ? ULONG_MAX : (ULONG)len;
 
 		if (ctx->prov->prov.cng.hash_data(ctx->ctx.cng.hash_handle, data, chunk, 0) < 0) {
-			giterr_set(GITERR_OS, "hash could not be updated");
+			git_error_set(GIT_ERROR_OS, "hash could not be updated");
 			return -1;
 		}
 
@@ -251,10 +261,10 @@ GIT_INLINE(int) hash_cng_update(git_hash_ctx *ctx, const void *_data, size_t len
 	return 0;
 }
 
-GIT_INLINE(int) hash_cng_final(git_oid *out, git_hash_ctx *ctx)
+GIT_INLINE(int) hash_cng_final(git_oid *out, git_hash_sha1_ctx *ctx)
 {
 	if (ctx->prov->prov.cng.finish_hash(ctx->ctx.cng.hash_handle, out->id, GIT_OID_RAWSZ, 0) < 0) {
-		giterr_set(GITERR_OS, "hash could not be finished");
+		git_error_set(GIT_ERROR_OS, "hash could not be finished");
 		return -1;
 	}
 
@@ -263,7 +273,7 @@ GIT_INLINE(int) hash_cng_final(git_oid *out, git_hash_ctx *ctx)
 	return 0;
 }
 
-GIT_INLINE(void) hash_ctx_cng_cleanup(git_hash_ctx *ctx)
+GIT_INLINE(void) hash_ctx_cng_cleanup(git_hash_sha1_ctx *ctx)
 {
 	ctx->prov->prov.cng.destroy_hash(ctx->ctx.cng.hash_handle);
 	git__free(ctx->ctx.cng.hash_object);
@@ -271,7 +281,7 @@ GIT_INLINE(void) hash_ctx_cng_cleanup(git_hash_ctx *ctx)
 
 /* Indirection between CryptoAPI and CNG */
 
-int git_hash_ctx_init(git_hash_ctx *ctx)
+int git_hash_sha1_ctx_init(git_hash_sha1_ctx *ctx)
 {
 	int error = 0;
 
@@ -282,33 +292,33 @@ int git_hash_ctx_init(git_hash_ctx *ctx)
 	 * initialized with git_libgit2_init.  Otherwise, it must be initialized
 	 * at first use.
 	 */
-	if (hash_prov.type == INVALID && (error = git_hash_global_init()) < 0)
+	if (hash_prov.type == INVALID && (error = git_hash_sha1_global_init()) < 0)
 		return error;
 
-	memset(ctx, 0x0, sizeof(git_hash_ctx));
+	memset(ctx, 0x0, sizeof(git_hash_sha1_ctx));
 
 	return (hash_prov.type == CNG) ? hash_ctx_cng_init(ctx) : hash_ctx_cryptoapi_init(ctx);
 }
 
-int git_hash_init(git_hash_ctx *ctx)
+int git_hash_sha1_init(git_hash_sha1_ctx *ctx)
 {
 	assert(ctx && ctx->type);
 	return (ctx->type == CNG) ? hash_cng_init(ctx) : hash_cryptoapi_init(ctx);
 }
 
-int git_hash_update(git_hash_ctx *ctx, const void *data, size_t len)
+int git_hash_sha1_update(git_hash_sha1_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_final(git_oid *out, git_hash_ctx *ctx)
+int git_hash_sha1_final(git_oid *out, git_hash_sha1_ctx *ctx)
 {
 	assert(ctx && ctx->type);
 	return (ctx->type == CNG) ? hash_cng_final(out, ctx) : hash_cryptoapi_final(out, ctx);
 }
 
-void git_hash_ctx_cleanup(git_hash_ctx *ctx)
+void git_hash_sha1_ctx_cleanup(git_hash_sha1_ctx *ctx)
 {
 	assert(ctx);
 

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

@@ -5,12 +5,10 @@
  * a Linking Exception. For full terms see the included COPYING file.
  */
 
-#ifndef INCLUDE_hash_hash_win32_h__
-#define INCLUDE_hash_hash_win32_h__
+#ifndef INCLUDE_hash_sha1_win32_h__
+#define INCLUDE_hash_sha1_win32_h__
 
-#include "common.h"
-
-#include "hash.h"
+#include "hash/sha1.h"
 
 #include <wincrypt.h>
 #include <strsafe.h>
@@ -36,17 +34,6 @@ 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,
@@ -106,14 +93,14 @@ struct hash_cng_prov {
 	DWORD hash_object_size;
 };
 
-struct git_hash_prov {
+typedef struct {
 	enum hash_win32_prov_type type;
 
 	union {
 		struct hash_cryptoapi_prov cryptoapi;
 		struct hash_cng_prov cng;
 	} prov;
-};
+} git_hash_prov;
 
 /* Hash contexts */
 
@@ -128,7 +115,7 @@ struct hash_cng_ctx {
 	PBYTE hash_object;
 };
 
-struct git_hash_ctx {
+struct git_hash_sha1_ctx {
 	enum hash_win32_prov_type type;
 	git_hash_prov *prov;
 

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.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,32 +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"
-#elif defined(GIT_SHA1_MBEDTLS)
-# include "hash/hash_mbedtls.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/hashsig.c

@@ -8,7 +8,7 @@
 #include "common.h"
 
 #include "git2/sys/hashsig.h"
-#include "fileops.h"
+#include "futils.h"
 #include "util.h"
 
 typedef uint32_t hashsig_t;
@@ -216,7 +216,7 @@ static int hashsig_finalize_hashes(git_hashsig *sig)
 {
 	if (sig->mins.size < HASHSIG_HEAP_MIN_SIZE &&
 		!(sig->opt & GIT_HASHSIG_ALLOW_SMALL_FILES)) {
-		giterr_set(GITERR_INVALID,
+		git_error_set(GIT_ERROR_INVALID,
 			"file too small for similarity signature calculation");
 		return GIT_EBUFS;
 	}
@@ -249,7 +249,7 @@ int git_hashsig_create(
 	int error;
 	hashsig_in_progress prog;
 	git_hashsig *sig = hashsig_alloc(opts);
-	GITERR_CHECK_ALLOC(sig);
+	GIT_ERROR_CHECK_ALLOC(sig);
 
 	hashsig_in_progress_init(&prog, sig);
 
@@ -276,7 +276,7 @@ int git_hashsig_create_fromfile(
 	int error = 0, fd;
 	hashsig_in_progress prog;
 	git_hashsig *sig = hashsig_alloc(opts);
-	GITERR_CHECK_ALLOC(sig);
+	GIT_ERROR_CHECK_ALLOC(sig);
 
 	if ((fd = git_futils_open_ro(path)) < 0) {
 		git__free(sig);
@@ -288,7 +288,7 @@ int git_hashsig_create_fromfile(
 	while (!error) {
 		if ((buflen = p_read(fd, buf, sizeof(buf))) <= 0) {
 			if ((error = (int)buflen) < 0)
-				giterr_set(GITERR_OS,
+				git_error_set(GIT_ERROR_OS,
 					"read error on '%s' calculating similarity hashes", path);
 			break;
 		}