star-ck

commit 1ee180806a12e47560c8ca020ff5845248be6f73
parent 76f9d4e1a578d5723007891404cbe9ba09c68a62
Author: Vincent Forest <vincent.forest@meso-star.com>
Date:   Tue,  6 Sep 2022 18:26:19 +0200

Update the hash computations

Rely on the sha256_ctx API

Diffstat:
M
src/sck.c
 | 
129
++++++++++++++++++++++++++++++++++++++-----------------------------------------

1 file changed, 62 insertions(+), 67 deletions(-)
diff --git a/src/sck.c b/src/sck.c
@@ -23,7 +23,6 @@
 #include "sck_log.h"
 
 #include <rsys/algorithm.h>
-#include <rsys/dynamic_array_char.h>
 
 #include <unistd.h> /* sysconf support */
 
@@ -325,6 +324,40 @@ error:
   goto exit;
 }
 
+static INLINE void
+hash_quad_pt
+  (struct sha256_ctx* ctx,
+   const struct sck_quad_pt* pt,
+   const size_t nnodes)
+{
+  ASSERT(ctx && pt);
+  #define HASH(Var, Nb) sha256_ctx_update(ctx, (const char*)(Var), sizeof(*Var)*(Nb))
+  HASH(&pt->weight, 1);
+  HASH(&pt->id, 1);
+  HASH(pt->ka_list, nnodes);
+  #undef HASH
+}
+
+static INLINE void
+hash_band(struct sha256_ctx* ctx, const struct sck_band* band)
+{
+  size_t iquad_pt;
+  ASSERT(ctx && band);
+
+  #define HASH(Var, Nb) sha256_ctx_update(ctx, (const char*)(Var), sizeof(*Var)*(Nb))
+  HASH(&band->lower, 1);
+  HASH(&band->upper, 1);
+  HASH(&band->quad_pts_count, 1);
+  HASH(band->ks_list, band->sck__->nnodes);
+  #undef HASH
+
+  FOR_EACH(iquad_pt, 0, band->quad_pts_count) {
+    struct sck_quad_pt quad_pt;
+    SCK(band_get_quad_pt(band, iquad_pt, &quad_pt));
+    hash_quad_pt(ctx, &quad_pt, band->sck__->nnodes);
+  }
+}
+
 static void
 release_sck(ref_T* ref)
 {
@@ -575,33 +608,23 @@ sck_quad_pt_compute_hash
    const size_t iquad_pt,
    hash256_T hash)
 {
-  struct darray_char bytes;
+  struct sha256_ctx ctx;
   struct sck_quad_pt quad_pt;
   res_T res = RES_OK;
 
-  if(!band || !hash) return RES_BAD_ARG;
-
-  darray_char_init(band->sck__->allocator, &bytes);
+  if(!band || !hash) {
+    res = RES_BAD_ARG;
+    goto error;
+  }
 
   res = sck_band_get_quad_pt(band, iquad_pt, &quad_pt);
   if(res != RES_OK) goto error;
 
-  #define WRITE(Var, Nb) {                                                     \
-    size_t ibyte;                                                              \
-    FOR_EACH(ibyte, 0, sizeof(*Var)*(Nb)) {                                    \
-      res = darray_char_push_back(&bytes, ((const char*)Var)+ibyte);           \
-      if(res != RES_OK) goto error;                                            \
-    }                                                                          \
-  } (void)0
-  WRITE(&quad_pt.weight, 1);
-  WRITE(&quad_pt.id, 1);
-  WRITE(quad_pt.ka_list, band->sck__->nnodes);
-  #undef WRITE
-
-  hash_sha256(darray_char_cdata_get(&bytes), darray_char_size_get(&bytes), hash);
+  sha256_ctx_init(&ctx);
+  hash_quad_pt(&ctx, &quad_pt, band->sck__->nnodes);
+  sha256_ctx_finalize(&ctx, hash);
 
 exit:
-  darray_char_release(&bytes);
   return res;
 error:
   goto exit;
@@ -613,42 +636,23 @@ sck_band_compute_hash
    const size_t iband,
    hash256_T hash)
 {
-  struct darray_char bytes;
+  struct sha256_ctx ctx;
   struct sck_band band;
-  size_t iquad_pt;
   res_T res = RES_OK;
 
-  if(!sck || !hash) return RES_BAD_ARG;
-
-  darray_char_init(sck->allocator, &bytes);
+  if(!sck || !hash) {
+    res =  RES_BAD_ARG;
+    goto error;
+  }
 
   res = sck_get_band(sck, iband, &band);
   if(res != RES_OK) goto error;
 
-  #define WRITE(Var, Nb) {                                                     \
-    size_t ibyte;                                                              \
-    FOR_EACH(ibyte, 0, sizeof(*Var)*(Nb)) {                                    \
-      res = darray_char_push_back(&bytes, ((const char*)Var)+ibyte);           \
-      if(res != RES_OK) goto error;                                            \
-    }                                                                          \
-  } (void)0
-  WRITE(&band.lower, 1);
-  WRITE(&band.upper, 1);
-  WRITE(&band.quad_pts_count, 1);
-  WRITE(&band.id, 1);
-  WRITE(band.ks_list, sck->nnodes);
-  FOR_EACH(iquad_pt, 0, band.quad_pts_count) {
-    hash256_T quad_pt_hash;
-    res = sck_quad_pt_compute_hash(&band, iquad_pt, quad_pt_hash);
-    if(res != RES_OK) goto error;
-    WRITE(quad_pt_hash, sizeof(hash256_T));
-  }
-  #undef WRITE
-
-  hash_sha256(darray_char_cdata_get(&bytes), darray_char_size_get(&bytes), hash);
+  sha256_ctx_init(&ctx);
+  hash_band(&ctx, &band);
+  sha256_ctx_finalize(&ctx, hash);
 
 exit:
-  darray_char_release(&bytes);
   return res;
 error:
   goto exit;
@@ -657,35 +661,26 @@ error:
 res_T
 sck_compute_hash(const struct sck* sck, hash256_T hash)
 {
-  struct darray_char bytes;
+  struct sha256_ctx ctx;
   size_t iband;
   res_T res = RES_OK;
 
-  if(!sck || !hash) return RES_BAD_ARG;
-
-  darray_char_init(sck->allocator, &bytes);
+  if(!sck || !hash) {
+    res = RES_BAD_ARG;
+    goto error;
+  }
 
-  #define WRITE(Var, Nb) {                                                     \
-    size_t ibyte;                                                              \
-    FOR_EACH(ibyte, 0, sizeof(*Var)*(Nb)) {                                    \
-      res = darray_char_push_back(&bytes, ((const char*)Var)+ibyte);           \
-      if(res != RES_OK) goto error;                                            \
-    }                                                                          \
-  } (void)0
-  WRITE(&sck->pagesize, 1);
-  WRITE(&sck->nnodes, 1);
+  sha256_ctx_init(&ctx);
+  sha256_ctx_update(&ctx, (const char*)&sck->pagesize, sizeof(sck->pagesize));
+  sha256_ctx_update(&ctx, (const char*)&sck->nnodes, sizeof(sck->nnodes));
   FOR_EACH(iband, 0, darray_band_size_get(&sck->bands)) {
-    hash256_T band_hash;
-    res = sck_band_compute_hash(sck, iband, band_hash);
-    if(res != RES_OK) goto error;
-    WRITE(band_hash, sizeof(hash256_T));
+    struct sck_band band;
+    SCK(get_band(sck, iband, &band));
+    hash_band(&ctx, &band);
   }
-  #undef WRITE
-
-  hash_sha256(darray_char_cdata_get(&bytes), darray_char_size_get(&bytes), hash);
+  sha256_ctx_finalize(&ctx, hash);
 
 exit:
-  darray_char_release(&bytes);
   return res;
 error:
   goto exit;