hash: move SHA1 implementations to its own hashing context

pks-t · pks-t · commit 8832172e9b73 · 2019-06-24T18:33:22.000+02:00
Create a separate `git_hash_sha1_ctx` structure that is specific
to the SHA1 implementation and move all SHA1 functions over to
use that one instead of the generic `git_hash_ctx`. The
`git_hash_ctx` for now simply has a union containing this single
SHA1 implementation, only, without any mechanism to distinguish
between different algortihms.
diff --git a/src/hash.c b/src/hash.c
@@ -14,27 +14,27 @@ int git_hash_global_init(void)
 
 int git_hash_ctx_init(git_hash_ctx *ctx)
 {
-	return git_hash_sha1_ctx_init(ctx);
+	return git_hash_sha1_ctx_init(&ctx->sha1);
 }
 
 void git_hash_ctx_cleanup(git_hash_ctx *ctx)
 {
-	git_hash_sha1_ctx_cleanup(ctx);
+	git_hash_sha1_ctx_cleanup(&ctx->sha1);
 }
 
-int git_hash_init(git_hash_ctx *c)
+int git_hash_init(git_hash_ctx *ctx)
 {
-	return git_hash_sha1_init(c);
+	return git_hash_sha1_init(&ctx->sha1);
 }
 
-int git_hash_update(git_hash_ctx *c, const void *data, size_t len)
+int git_hash_update(git_hash_ctx *ctx, const void *data, size_t len)
 {
-	return git_hash_sha1_update(c, data, len);
+	return git_hash_sha1_update(&ctx->sha1, data, len);
 }
 
-int git_hash_final(git_oid *out, git_hash_ctx *c)
+int git_hash_final(git_oid *out, git_hash_ctx *ctx)
 {
-	return git_hash_sha1_final(out, c);
+	return git_hash_sha1_final(out, &ctx->sha1);
 }
 
 int git_hash_buf(git_oid *out, const void *data, size_t len)
diff --git a/src/hash.h b/src/hash.h
@@ -12,15 +12,19 @@
 
 #include "git2/oid.h"
 
-typedef struct git_hash_ctx git_hash_ctx;
-
 typedef struct {
 	void *data;
 	size_t len;
 } git_buf_vec;
 
 #include "hash/sha1.h"
 
+typedef struct git_hash_ctx {
+	union {
+		git_hash_sha1_ctx sha1;
+	};
+} git_hash_ctx;
+
 int git_hash_global_init(void);
 
 int git_hash_ctx_init(git_hash_ctx *ctx);
diff --git a/src/hash/sha1.h b/src/hash/sha1.h
@@ -10,6 +10,8 @@
 
 #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)
@@ -26,11 +28,11 @@
 
 int git_hash_sha1_global_init(void);
 
-int git_hash_sha1_ctx_init(git_hash_ctx *ctx);
-void git_hash_sha1_ctx_cleanup(git_hash_ctx *ctx);
+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_ctx *c);
-int git_hash_sha1_update(git_hash_ctx *c, const void *data, size_t len);
-int git_hash_sha1_final(git_oid *out, git_hash_ctx *c);
+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
diff --git a/src/hash/sha1/collisiondetect.c b/src/hash/sha1/collisiondetect.c
@@ -12,31 +12,31 @@ int git_hash_sha1_global_init(void)
 	return 0;
 }
 
-int git_hash_sha1_ctx_init(git_hash_ctx *ctx)
+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_ctx *ctx)
+void git_hash_sha1_ctx_cleanup(git_hash_sha1_ctx *ctx)
 {
 	GIT_UNUSED(ctx);
 }
 
-int git_hash_sha1_init(git_hash_ctx *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_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);
 	SHA1DCUpdate(&ctx->c, data, len);
 	return 0;
 }
 
-int git_hash_sha1_final(git_oid *out, git_hash_ctx *ctx)
+int git_hash_sha1_final(git_oid *out, git_hash_sha1_ctx *ctx)
 {
 	assert(ctx);
 	if (SHA1DCFinal(out->id, &ctx->c)) {
diff --git a/src/hash/sha1/collisiondetect.h b/src/hash/sha1/collisiondetect.h
@@ -8,11 +8,11 @@
 #ifndef INCLUDE_hash_sha1_collisiondetect_h__
 #define INCLUDE_hash_sha1_collisiondetect_h__
 
-#include "hash.h"
+#include "hash/sha1.h"
 
 #include "sha1dc/sha1.h"
 
-struct git_hash_ctx {
+struct git_hash_sha1_ctx {
 	SHA1_CTX c;
 };
 
diff --git a/src/hash/sha1/common_crypto.c b/src/hash/sha1/common_crypto.c
@@ -14,24 +14,24 @@ int git_hash_sha1_global_init(void)
 	return 0;
 }
 
-int git_hash_sha1_ctx_init(git_hash_ctx *ctx)
+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_ctx *ctx)
+void git_hash_sha1_ctx_cleanup(git_hash_sha1_ctx *ctx)
 {
 	GIT_UNUSED(ctx);
 }
 
-int git_hash_sha1_init(git_hash_ctx *ctx)
+int git_hash_sha1_init(git_hash_sha1_ctx *ctx)
 {
 	assert(ctx);
 	CC_SHA1_Init(&ctx->c);
 	return 0;
 }
 
-int git_hash_sha1_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)
 {
 	const unsigned char *data = _data;
 
@@ -49,7 +49,7 @@ int git_hash_sha1_update(git_hash_ctx *ctx, const void *_data, size_t len)
 	return 0;
 }
 
-int git_hash_sha1_final(git_oid *out, git_hash_ctx *ctx)
+int git_hash_sha1_final(git_oid *out, git_hash_sha1_ctx *ctx)
 {
 	assert(ctx);
 	CC_SHA1_Final(out->id, &ctx->c);
diff --git a/src/hash/sha1/common_crypto.h b/src/hash/sha1/common_crypto.h
@@ -8,11 +8,11 @@
 #ifndef INCLUDE_hash_sha1_common_crypto_h__
 #define INCLUDE_hash_sha1_common_crypto_h__
 
-#include "hash.h"
+#include "hash/sha1.h"
 
 #include <CommonCrypto/CommonDigest.h>
 
-struct git_hash_ctx {
+struct git_hash_sha1_ctx {
 	CC_SHA1_CTX c;
 };
 
diff --git a/src/hash/sha1/generic.c b/src/hash/sha1/generic.c
@@ -111,7 +111,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_ctx *ctx, const unsigned int *data)
+static void hash__block(git_hash_sha1_ctx *ctx, const unsigned int *data)
 {
 	unsigned int A,B,C,D,E;
 	unsigned int array[16];
@@ -224,17 +224,17 @@ int git_hash_sha1_global_init(void)
 	return 0;
 }
 
-int git_hash_sha1_ctx_init(git_hash_ctx *ctx)
+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_ctx *ctx)
+void git_hash_sha1_ctx_cleanup(git_hash_sha1_ctx *ctx)
 {
 	GIT_UNUSED(ctx);
 }
 
-int git_hash_sha1_init(git_hash_ctx *ctx)
+int git_hash_sha1_init(git_hash_sha1_ctx *ctx)
 {
 	ctx->size = 0;
 
@@ -248,7 +248,7 @@ int git_hash_sha1_init(git_hash_ctx *ctx)
 	return 0;
 }
 
-int git_hash_sha1_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)
 {
 	unsigned int lenW = ctx->size & 63;
 
@@ -278,7 +278,7 @@ int git_hash_sha1_update(git_hash_ctx *ctx, const void *data, size_t len)
 	return 0;
 }
 
-int git_hash_sha1_final(git_oid *out, git_hash_ctx *ctx)
+int git_hash_sha1_final(git_oid *out, git_hash_sha1_ctx *ctx)
 {
 	static const unsigned char pad[64] = { 0x80 };
 	unsigned int padlen[2];
@@ -289,8 +289,8 @@ int git_hash_sha1_final(git_oid *out, git_hash_ctx *ctx)
 	padlen[1] = htonl((uint32_t)(ctx->size << 3));
 
 	i = ctx->size & 63;
-	git_hash_update(ctx, pad, 1+ (63 & (55 - i)));
-	git_hash_update(ctx, padlen, 8);
+	git_hash_sha1_update(ctx, pad, 1+ (63 & (55 - i)));
+	git_hash_sha1_update(ctx, padlen, 8);
 
 	/* Output hash */
 	for (i = 0; i < 5; i++)
diff --git a/src/hash/sha1/generic.h b/src/hash/sha1/generic.h
@@ -8,9 +8,9 @@
 #ifndef INCLUDE_hash_sha1_generic_h__
 #define INCLUDE_hash_sha1_generic_h__
 
-#include "hash.h"
+#include "hash/sha1.h"
 
-struct git_hash_ctx {
+struct git_hash_sha1_ctx {
 	unsigned long long size;
 	unsigned int H[5];
 	unsigned int W[16];
diff --git a/src/hash/sha1/mbedtls.c b/src/hash/sha1/mbedtls.c
@@ -12,33 +12,33 @@ int git_hash_sha1_global_init(void)
 	return 0;
 }
 
-int git_hash_sha1_ctx_init(git_hash_ctx *ctx)
+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_ctx *ctx)
+void git_hash_sha1_ctx_cleanup(git_hash_sha1_ctx *ctx)
 {
     assert(ctx);
     mbedtls_sha1_free(&ctx->c);
 }
 
-int git_hash_sha1_init(git_hash_ctx *ctx)
+int git_hash_sha1_init(git_hash_sha1_ctx *ctx)
 {
     assert(ctx);
     mbedtls_sha1_init(&ctx->c);
     mbedtls_sha1_starts(&ctx->c);
     return 0;
 }
 
-int git_hash_sha1_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);
     mbedtls_sha1_update(&ctx->c, data, len);
     return 0;
 }
 
-int git_hash_sha1_final(git_oid *out, git_hash_ctx *ctx)
+int git_hash_sha1_final(git_oid *out, git_hash_sha1_ctx *ctx)
 {
     assert(ctx);
     mbedtls_sha1_finish(&ctx->c, out->id);
diff --git a/src/hash/sha1/mbedtls.h b/src/hash/sha1/mbedtls.h
@@ -8,11 +8,11 @@
 #ifndef INCLUDE_hash_sha1_mbedtls_h__
 #define INCLUDE_hash_sha1_mbedtls_h__
 
-#include "hash.h"
+#include "hash/sha1.h"
 
 #include <mbedtls/sha1.h>
 
-struct git_hash_ctx {
+struct git_hash_sha1_ctx {
     mbedtls_sha1_context c;
 };
 
diff --git a/src/hash/sha1/openssl.c b/src/hash/sha1/openssl.c
@@ -12,17 +12,17 @@ int git_hash_sha1_global_init(void)
 	return 0;
 }
 
-int git_hash_sha1_ctx_init(git_hash_ctx *ctx)
+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_ctx *ctx)
+void git_hash_sha1_ctx_cleanup(git_hash_sha1_ctx *ctx)
 {
 	GIT_UNUSED(ctx);
 }
 
-int git_hash_sha1_init(git_hash_ctx *ctx)
+int git_hash_sha1_init(git_hash_sha1_ctx *ctx)
 {
 	assert(ctx);
 
@@ -34,7 +34,7 @@ int git_hash_sha1_init(git_hash_ctx *ctx)
 	return 0;
 }
 
-int git_hash_sha1_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);
 
@@ -46,7 +46,7 @@ int git_hash_sha1_update(git_hash_ctx *ctx, const void *data, size_t len)
 	return 0;
 }
 
-int git_hash_sha1_final(git_oid *out, git_hash_ctx *ctx)
+int git_hash_sha1_final(git_oid *out, git_hash_sha1_ctx *ctx)
 {
 	assert(ctx);
 
diff --git a/src/hash/sha1/openssl.h b/src/hash/sha1/openssl.h
@@ -8,13 +8,11 @@
 #ifndef INCLUDE_hash_sha1_openssl_h__
 #define INCLUDE_hash_sha1_openssl_h__
 
-#include "common.h"
-
-#include "hash.h"
+#include "hash/sha1.h"
 
 #include <openssl/sha.h>
 
-struct git_hash_ctx {
+struct git_hash_sha1_ctx {
 	SHA_CTX c;
 };
 
diff --git a/src/hash/sha1/win32.c b/src/hash/sha1/win32.c
diff --git a/src/hash/sha1/win32.h b/src/hash/sha1/win32.h

Original file line number	Diff line number	Diff line change
`@@ -14,27 +14,27 @@ int git_hash_global_init(void)`
`14`	`14`
`15`	`15`	`int git_hash_ctx_init(git_hash_ctx *ctx)`
`16`	`16`	`{`
`17`		`- return git_hash_sha1_ctx_init(ctx);`
	`17`	`+ return git_hash_sha1_ctx_init(&ctx->sha1);`
`18`	`18`	`}`
`19`	`19`
`20`	`20`	`void git_hash_ctx_cleanup(git_hash_ctx *ctx)`
`21`	`21`	`{`
`22`		`- git_hash_sha1_ctx_cleanup(ctx);`
	`22`	`+ git_hash_sha1_ctx_cleanup(&ctx->sha1);`
`23`	`23`	`}`
`24`	`24`
`25`		`-int git_hash_init(git_hash_ctx *c)`
	`25`	`+int git_hash_init(git_hash_ctx *ctx)`
`26`	`26`	`{`
`27`		`- return git_hash_sha1_init(c);`
	`27`	`+ return git_hash_sha1_init(&ctx->sha1);`
`28`	`28`	`}`
`29`	`29`
`30`		`-int git_hash_update(git_hash_ctx c, const void data, size_t len)`
	`30`	`+int git_hash_update(git_hash_ctx ctx, const void data, size_t len)`
`31`	`31`	`{`
`32`		`- return git_hash_sha1_update(c, data, len);`
	`32`	`+ return git_hash_sha1_update(&ctx->sha1, data, len);`
`33`	`33`	`}`
`34`	`34`
`35`		`-int git_hash_final(git_oid out, git_hash_ctx c)`
	`35`	`+int git_hash_final(git_oid out, git_hash_ctx ctx)`
`36`	`36`	`{`
`37`		`- return git_hash_sha1_final(out, c);`
	`37`	`+ return git_hash_sha1_final(out, &ctx->sha1);`
`38`	`38`	`}`
`39`	`39`
`40`	`40`	`int git_hash_buf(git_oid out, const void data, size_t len)`
Original file line number	Diff line number	Diff line change
`@@ -12,31 +12,31 @@ int git_hash_sha1_global_init(void)`
`12`	`12`	`return 0;`
`13`	`13`	`}`
`14`	`14`
`15`		`-int git_hash_sha1_ctx_init(git_hash_ctx *ctx)`
	`15`	`+int git_hash_sha1_ctx_init(git_hash_sha1_ctx *ctx)`
`16`	`16`	`{`
`17`	`17`	`return git_hash_sha1_init(ctx);`
`18`	`18`	`}`
`19`	`19`
`20`		`-void git_hash_sha1_ctx_cleanup(git_hash_ctx *ctx)`
	`20`	`+void git_hash_sha1_ctx_cleanup(git_hash_sha1_ctx *ctx)`
`21`	`21`	`{`
`22`	`22`	`GIT_UNUSED(ctx);`
`23`	`23`	`}`
`24`	`24`
`25`		`-int git_hash_sha1_init(git_hash_ctx *ctx)`
	`25`	`+int git_hash_sha1_init(git_hash_sha1_ctx *ctx)`
`26`	`26`	`{`
`27`	`27`	`assert(ctx);`
`28`	`28`	`SHA1DCInit(&ctx->c);`
`29`	`29`	`return 0;`
`30`	`30`	`}`
`31`	`31`
`32`		`-int git_hash_sha1_update(git_hash_ctx ctx, const void data, size_t len)`
	`32`	`+int git_hash_sha1_update(git_hash_sha1_ctx ctx, const void data, size_t len)`
`33`	`33`	`{`
`34`	`34`	`assert(ctx);`
`35`	`35`	`SHA1DCUpdate(&ctx->c, data, len);`
`36`	`36`	`return 0;`
`37`	`37`	`}`
`38`	`38`
`39`		`-int git_hash_sha1_final(git_oid out, git_hash_ctx ctx)`
	`39`	`+int git_hash_sha1_final(git_oid out, git_hash_sha1_ctx ctx)`
`40`	`40`	`{`
`41`	`41`	`assert(ctx);`
`42`	`42`	`if (SHA1DCFinal(out->id, &ctx->c)) {`
Original file line number	Diff line number	Diff line change
`@@ -14,24 +14,24 @@ int git_hash_sha1_global_init(void)`
`14`	`14`	`return 0;`
`15`	`15`	`}`
`16`	`16`
`17`		`-int git_hash_sha1_ctx_init(git_hash_ctx *ctx)`
	`17`	`+int git_hash_sha1_ctx_init(git_hash_sha1_ctx *ctx)`
`18`	`18`	`{`
`19`	`19`	`return git_hash_sha1_init(ctx);`
`20`	`20`	`}`
`21`	`21`
`22`		`-void git_hash_sha1_ctx_cleanup(git_hash_ctx *ctx)`
	`22`	`+void git_hash_sha1_ctx_cleanup(git_hash_sha1_ctx *ctx)`
`23`	`23`	`{`
`24`	`24`	`GIT_UNUSED(ctx);`
`25`	`25`	`}`
`26`	`26`
`27`		`-int git_hash_sha1_init(git_hash_ctx *ctx)`
	`27`	`+int git_hash_sha1_init(git_hash_sha1_ctx *ctx)`
`28`	`28`	`{`
`29`	`29`	`assert(ctx);`
`30`	`30`	`CC_SHA1_Init(&ctx->c);`
`31`	`31`	`return 0;`
`32`	`32`	`}`
`33`	`33`
`34`		`-int git_hash_sha1_update(git_hash_ctx ctx, const void _data, size_t len)`
	`34`	`+int git_hash_sha1_update(git_hash_sha1_ctx ctx, const void _data, size_t len)`
`35`	`35`	`{`
`36`	`36`	`const unsigned char *data = _data;`
`37`	`37`
`@@ -49,7 +49,7 @@ int git_hash_sha1_update(git_hash_ctx ctx, const void _data, size_t len)`
`49`	`49`	`return 0;`
`50`	`50`	`}`
`51`	`51`
`52`		`-int git_hash_sha1_final(git_oid out, git_hash_ctx ctx)`
	`52`	`+int git_hash_sha1_final(git_oid out, git_hash_sha1_ctx ctx)`
`53`	`53`	`{`
`54`	`54`	`assert(ctx);`
`55`	`55`	`CC_SHA1_Final(out->id, &ctx->c);`
Original file line number	Diff line number	Diff line change
`@@ -111,7 +111,7 @@`
`111`	`111`	`#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 )`
`112`	`112`	`#define T_60_79(t, A, B, C, D, E) SHA_ROUND(t, SHA_MIX, (B^C^D) , 0xca62c1d6, A, B, C, D, E )`
`113`	`113`
`114`		`-static void hash__block(git_hash_ctx ctx, const unsigned int data)`
	`114`	`+static void hash__block(git_hash_sha1_ctx ctx, const unsigned int data)`
`115`	`115`	`{`
`116`	`116`	`unsigned int A,B,C,D,E;`
`117`	`117`	`unsigned int array[16];`
`@@ -224,17 +224,17 @@ int git_hash_sha1_global_init(void)`
`224`	`224`	`return 0;`
`225`	`225`	`}`
`226`	`226`
`227`		`-int git_hash_sha1_ctx_init(git_hash_ctx *ctx)`
	`227`	`+int git_hash_sha1_ctx_init(git_hash_sha1_ctx *ctx)`
`228`	`228`	`{`
`229`	`229`	`return git_hash_sha1_init(ctx);`
`230`	`230`	`}`
`231`	`231`
`232`		`-void git_hash_sha1_ctx_cleanup(git_hash_ctx *ctx)`
	`232`	`+void git_hash_sha1_ctx_cleanup(git_hash_sha1_ctx *ctx)`
`233`	`233`	`{`
`234`	`234`	`GIT_UNUSED(ctx);`
`235`	`235`	`}`
`236`	`236`
`237`		`-int git_hash_sha1_init(git_hash_ctx *ctx)`
	`237`	`+int git_hash_sha1_init(git_hash_sha1_ctx *ctx)`
`238`	`238`	`{`
`239`	`239`	`ctx->size = 0;`
`240`	`240`
`@@ -248,7 +248,7 @@ int git_hash_sha1_init(git_hash_ctx *ctx)`
`248`	`248`	`return 0;`
`249`	`249`	`}`
`250`	`250`
`251`		`-int git_hash_sha1_update(git_hash_ctx ctx, const void data, size_t len)`
	`251`	`+int git_hash_sha1_update(git_hash_sha1_ctx ctx, const void data, size_t len)`
`252`	`252`	`{`
`253`	`253`	`unsigned int lenW = ctx->size & 63;`
`254`	`254`
`@@ -278,7 +278,7 @@ int git_hash_sha1_update(git_hash_ctx ctx, const void data, size_t len)`
`278`	`278`	`return 0;`
`279`	`279`	`}`
`280`	`280`
`281`		`-int git_hash_sha1_final(git_oid out, git_hash_ctx ctx)`
	`281`	`+int git_hash_sha1_final(git_oid out, git_hash_sha1_ctx ctx)`
`282`	`282`	`{`
`283`	`283`	`static const unsigned char pad[64] = { 0x80 };`
`284`	`284`	`unsigned int padlen[2];`
`@@ -289,8 +289,8 @@ int git_hash_sha1_final(git_oid out, git_hash_ctx ctx)`
`289`	`289`	`padlen[1] = htonl((uint32_t)(ctx->size << 3));`
`290`	`290`
`291`	`291`	`i = ctx->size & 63;`
`292`		`- git_hash_update(ctx, pad, 1+ (63 & (55 - i)));`
`293`		`- git_hash_update(ctx, padlen, 8);`
	`292`	`+ git_hash_sha1_update(ctx, pad, 1+ (63 & (55 - i)));`
	`293`	`+ git_hash_sha1_update(ctx, padlen, 8);`
`294`	`294`
`295`	`295`	`/* Output hash */`
`296`	`296`	`for (i = 0; i < 5; i++)`
Original file line number	Diff line number	Diff line change
`@@ -12,33 +12,33 @@ int git_hash_sha1_global_init(void)`
`12`	`12`	`return 0;`
`13`	`13`	`}`
`14`	`14`
`15`		`-int git_hash_sha1_ctx_init(git_hash_ctx *ctx)`
	`15`	`+int git_hash_sha1_ctx_init(git_hash_sha1_ctx *ctx)`
`16`	`16`	`{`
`17`	`17`	`return git_hash_sha1_init(ctx);`
`18`	`18`	`}`
`19`	`19`
`20`		`-void git_hash_sha1_ctx_cleanup(git_hash_ctx *ctx)`
	`20`	`+void git_hash_sha1_ctx_cleanup(git_hash_sha1_ctx *ctx)`
`21`	`21`	`{`
`22`	`22`	`assert(ctx);`
`23`	`23`	`mbedtls_sha1_free(&ctx->c);`
`24`	`24`	`}`
`25`	`25`
`26`		`-int git_hash_sha1_init(git_hash_ctx *ctx)`
	`26`	`+int git_hash_sha1_init(git_hash_sha1_ctx *ctx)`
`27`	`27`	`{`
`28`	`28`	`assert(ctx);`
`29`	`29`	`mbedtls_sha1_init(&ctx->c);`
`30`	`30`	`mbedtls_sha1_starts(&ctx->c);`
`31`	`31`	`return 0;`
`32`	`32`	`}`
`33`	`33`
`34`		`-int git_hash_sha1_update(git_hash_ctx ctx, const void data, size_t len)`
	`34`	`+int git_hash_sha1_update(git_hash_sha1_ctx ctx, const void data, size_t len)`
`35`	`35`	`{`
`36`	`36`	`assert(ctx);`
`37`	`37`	`mbedtls_sha1_update(&ctx->c, data, len);`
`38`	`38`	`return 0;`
`39`	`39`	`}`
`40`	`40`
`41`		`-int git_hash_sha1_final(git_oid out, git_hash_ctx ctx)`
	`41`	`+int git_hash_sha1_final(git_oid out, git_hash_sha1_ctx ctx)`
`42`	`42`	`{`
`43`	`43`	`assert(ctx);`
`44`	`44`	`mbedtls_sha1_finish(&ctx->c, out->id);`