/*
- * This file is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License, version 2,
- * as published by the Free Software Foundation.
+ * Copyright (C) the libgit2 contributors. All rights reserved.
*
- * In addition to the permissions in the GNU General Public License,
- * the authors give you unlimited permission to link the compiled
- * version of this file into combinations with other programs,
- * and to distribute those combinations without any restriction
- * coming from the use of this file. (The General Public License
- * restrictions do apply in other respects; for example, they cover
- * modification of the file, and distribution when not linked into
- * a combined executable.)
- *
- * This file is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; see the file COPYING. If not, write to
- * the Free Software Foundation, 51 Franklin Street, Fifth Floor,
- * Boston, MA 02110-1301, USA.
+ * 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 "common.h"
#include "hash.h"
-#if defined(PPC_SHA1)
-# include "ppc/sha1.h"
-#else
-# include "sha1.h"
-#endif
-
-struct git_hash_ctx {
- SHA_CTX c;
-};
+int git_hash_global_init(void)
+{
+ return git_hash_sha1_global_init();
+}
-git_hash_ctx *git_hash_new_ctx(void)
+int git_hash_ctx_init(git_hash_ctx *ctx)
{
- git_hash_ctx *ctx = git__malloc(sizeof(*ctx));
+ int error;
- if (!ctx)
- return NULL;
+ if ((error = git_hash_sha1_ctx_init(&ctx->ctx.sha1)) < 0)
+ return error;
- SHA1_Init(&ctx->c);
+ ctx->algo = GIT_HASH_ALGO_SHA1;
- return ctx;
+ return 0;
}
-void git_hash_free_ctx(git_hash_ctx *ctx)
+void git_hash_ctx_cleanup(git_hash_ctx *ctx)
{
- free(ctx);
+ switch (ctx->algo) {
+ case GIT_HASH_ALGO_SHA1:
+ git_hash_sha1_ctx_cleanup(&ctx->ctx.sha1);
+ return;
+ default:
+ /* unreachable */ ;
+ }
}
-void git_hash_init(git_hash_ctx *ctx)
+int git_hash_init(git_hash_ctx *ctx)
{
- assert(ctx);
- SHA1_Init(&ctx->c);
+ switch (ctx->algo) {
+ case GIT_HASH_ALGO_SHA1:
+ return git_hash_sha1_init(&ctx->ctx.sha1);
+ default:
+ /* unreachable */ ;
+ }
+ GIT_ASSERT(0);
+ return -1;
}
-void git_hash_update(git_hash_ctx *ctx, const void *data, size_t len)
+int git_hash_update(git_hash_ctx *ctx, const void *data, size_t len)
{
- assert(ctx);
- SHA1_Update(&ctx->c, data, len);
+ switch (ctx->algo) {
+ case GIT_HASH_ALGO_SHA1:
+ return git_hash_sha1_update(&ctx->ctx.sha1, data, len);
+ default:
+ /* unreachable */ ;
+ }
+ GIT_ASSERT(0);
+ return -1;
}
-void git_hash_final(git_oid *out, git_hash_ctx *ctx)
+int git_hash_final(git_oid *out, git_hash_ctx *ctx)
{
- assert(ctx);
- SHA1_Final(out->id, &ctx->c);
+ switch (ctx->algo) {
+ case GIT_HASH_ALGO_SHA1:
+ return git_hash_sha1_final(out, &ctx->ctx.sha1);
+ default:
+ /* unreachable */ ;
+ }
+ GIT_ASSERT(0);
+ return -1;
}
-void git_hash_buf(git_oid *out, const void *data, size_t len)
+int git_hash_buf(git_oid *out, const void *data, size_t len)
{
- SHA_CTX c;
+ git_hash_ctx ctx;
+ int error = 0;
+
+ if (git_hash_ctx_init(&ctx) < 0)
+ return -1;
- SHA1_Init(&c);
- SHA1_Update(&c, data, len);
- SHA1_Final(out->id, &c);
+ if ((error = git_hash_update(&ctx, data, len)) >= 0)
+ error = git_hash_final(out, &ctx);
+
+ git_hash_ctx_cleanup(&ctx);
+
+ return error;
}
-void git_hash_vec(git_oid *out, git_buf_vec *vec, size_t n)
+int git_hash_vec(git_oid *out, git_buf_vec *vec, size_t n)
{
- SHA_CTX c;
+ git_hash_ctx ctx;
size_t i;
+ int error = 0;
+
+ if (git_hash_ctx_init(&ctx) < 0)
+ return -1;
+
+ for (i = 0; i < n; i++) {
+ if ((error = git_hash_update(&ctx, vec[i].data, vec[i].len)) < 0)
+ goto done;
+ }
+
+ error = git_hash_final(out, &ctx);
+
+done:
+ git_hash_ctx_cleanup(&ctx);
- SHA1_Init(&c);
- for (i = 0; i < n; i++)
- SHA1_Update(&c, vec[i].data, vec[i].len);
- SHA1_Final(out->id, &c);
+ return error;
}