reftable: explicitly handle hash format IDs

The hash format IDs are used for two different things across the
reftable codebase:

  - They are used as a 32 bit unsigned integer when reading and writing
    the header in order to identify the hash function.

  - They are used internally to identify which hash function is in use.

When one only considers the second usecase one might think that one can
easily change the representation of those hash IDs. But because those
IDs end up in the reftable header and footer on disk it is important
that those never change.

Create separate constants `REFTABLE_FORMAT_ID_*` and use them in
contexts where we read or write reftable headers. This serves multiple
purposes:

  - It allows us to more easily discern cases where we actually use
    those constants for the on-disk format.

  - It detangles us from the same constants that are defined in
    libgit.a, which is another required step to convert the reftable
    library to become standalone.

  - It makes the next step easier where we stop using `GIT_*_FORMAT_ID`
    constants in favor of a custom enum.

Signed-off-by: Patrick Steinhardt <ps@pks.im>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/reftable/basics.h b/reftable/basics.h
index 7aa46d7c30d6504f2b61b74a17a60977b4f4efb7..bcab0b529b089e355bef8e78613e60acb53da0ed 100644 (file)
--- a/reftable/basics.h
+++ b/reftable/basics.h
@@ -150,4 +150,12 @@ int common_prefix_size(struct reftable_buf *a, struct reftable_buf *b);
 
 int hash_size(uint32_t id);
 
+/*
+ * Format IDs that identify the hash function used by a reftable. Note that
+ * these constants end up on disk and thus mustn't change. The format IDs are
+ * "sha1" and "s256" in big endian, respectively.
+ */
+#define REFTABLE_FORMAT_ID_SHA1   ((uint32_t) 0x73686131)
+#define REFTABLE_FORMAT_ID_SHA256 ((uint32_t) 0x73323536)
+
 #endif

diff --git a/reftable/reader.c b/reftable/reader.c
index 90dc950b5774ccafad206e214494eda5f8ba66f1..64eb6938efed8f4f8c9ed5b671dc9b86706d4f97 100644 (file)
--- a/reftable/reader.c
+++ b/reftable/reader.c
@@ -109,16 +109,18 @@ static int parse_footer(struct reftable_reader *r, uint8_t *footer,
        if (r->version == 1) {
                r->hash_id = GIT_SHA1_FORMAT_ID;
        } else {
-               r->hash_id = get_be32(f);
-               switch (r->hash_id) {
-               case GIT_SHA1_FORMAT_ID:
+               switch (get_be32(f)) {
+               case REFTABLE_FORMAT_ID_SHA1:
+                       r->hash_id = GIT_SHA1_FORMAT_ID;
                        break;
-               case GIT_SHA256_FORMAT_ID:
+               case REFTABLE_FORMAT_ID_SHA256:
+                       r->hash_id = GIT_SHA256_FORMAT_ID;
                        break;
                default:
                        err = REFTABLE_FORMAT_ERROR;
                        goto done;
                }
+
                f += 4;
        }
 

diff --git a/reftable/writer.c b/reftable/writer.c
index fd136794d5a27b33b5017f36fbd6b095ab8dac5b..9aa45de63401a28c3f8a3ebdc69922459251454d 100644 (file)
--- a/reftable/writer.c
+++ b/reftable/writer.c
@@ -103,8 +103,22 @@ static int writer_write_header(struct reftable_writer *w, uint8_t *dest)
        put_be64(dest + 8, w->min_update_index);
        put_be64(dest + 16, w->max_update_index);
        if (writer_version(w) == 2) {
-               put_be32(dest + 24, w->opts.hash_id);
+               uint32_t hash_id;
+
+               switch (w->opts.hash_id) {
+               case GIT_SHA1_FORMAT_ID:
+                       hash_id = REFTABLE_FORMAT_ID_SHA1;
+                       break;
+               case GIT_SHA256_FORMAT_ID:
+                       hash_id = REFTABLE_FORMAT_ID_SHA256;
+                       break;
+               default:
+                       return -1;
+               }
+
+               put_be32(dest + 24, hash_id);
        }
+
        return header_size(writer_version(w));
 }