reftable/basics: provide wrappers for big endian conversion

We're using a mixture of big endian conversion functions provided by
both the reftable library, but also by the Git codebase. Refactor the
code so that we exclusively use reftable-provided wrappers in order to
untangle us from the Git codebase.

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

diff --git a/reftable/basics.c b/reftable/basics.c
index 3b5ea27bbdc56ed9cc3d475a649a26d9f294e636..8c4a4433e41100bb5e19da44cb97464efd640ceb 100644 (file)
--- a/reftable/basics.c
+++ b/reftable/basics.c
@@ -147,25 +147,6 @@ char *reftable_buf_detach(struct reftable_buf *buf)
        return result;
 }
 
-void put_be24(uint8_t *out, uint32_t i)
-{
-       out[0] = (uint8_t)((i >> 16) & 0xff);
-       out[1] = (uint8_t)((i >> 8) & 0xff);
-       out[2] = (uint8_t)(i & 0xff);
-}
-
-uint32_t get_be24(uint8_t *in)
-{
-       return (uint32_t)(in[0]) << 16 | (uint32_t)(in[1]) << 8 |
-              (uint32_t)(in[2]);
-}
-
-void put_be16(uint8_t *out, uint16_t i)
-{
-       out[0] = (uint8_t)((i >> 8) & 0xff);
-       out[1] = (uint8_t)(i & 0xff);
-}
-
 size_t binsearch(size_t sz, int (*f)(size_t k, void *args), void *args)
 {
        size_t lo = 0;

diff --git a/reftable/basics.h b/reftable/basics.h
index 646f8d67f2d4decab34c5d508d33f03fbbf6a988..c1ddbaec3ff581bdfd2569efb51954c551705cc0 100644 (file)
--- a/reftable/basics.h
+++ b/reftable/basics.h
@@ -76,9 +76,79 @@ char *reftable_buf_detach(struct reftable_buf *buf);
 
 /* Bigendian en/decoding of integers */
 
-void put_be24(uint8_t *out, uint32_t i);
-uint32_t get_be24(uint8_t *in);
-void put_be16(uint8_t *out, uint16_t i);
+static inline void reftable_put_be16(void *out, uint16_t i)
+{
+       unsigned char *p = out;
+       p[0] = (uint8_t)((i >> 8) & 0xff);
+       p[1] = (uint8_t)((i >> 0) & 0xff);
+}
+
+static inline void reftable_put_be24(void *out, uint32_t i)
+{
+       unsigned char *p = out;
+       p[0] = (uint8_t)((i >> 16) & 0xff);
+       p[1] = (uint8_t)((i >>  8) & 0xff);
+       p[2] = (uint8_t)((i >>  0) & 0xff);
+}
+
+static inline void reftable_put_be32(void *out, uint32_t i)
+{
+       unsigned char *p = out;
+       p[0] = (uint8_t)((i >> 24) & 0xff);
+       p[1] = (uint8_t)((i >> 16) & 0xff);
+       p[2] = (uint8_t)((i >>  8) & 0xff);
+       p[3] = (uint8_t)((i >>  0) & 0xff);
+}
+
+static inline void reftable_put_be64(void *out, uint64_t i)
+{
+       unsigned char *p = out;
+       p[0] = (uint8_t)((i >> 56) & 0xff);
+       p[1] = (uint8_t)((i >> 48) & 0xff);
+       p[2] = (uint8_t)((i >> 40) & 0xff);
+       p[3] = (uint8_t)((i >> 32) & 0xff);
+       p[4] = (uint8_t)((i >> 24) & 0xff);
+       p[5] = (uint8_t)((i >> 16) & 0xff);
+       p[6] = (uint8_t)((i >>  8) & 0xff);
+       p[7] = (uint8_t)((i >>  0) & 0xff);
+}
+
+static inline uint16_t reftable_get_be16(const void *in)
+{
+       const unsigned char *p = in;
+       return (uint16_t)(p[0]) << 8 |
+              (uint16_t)(p[1]) << 0;
+}
+
+static inline uint32_t reftable_get_be24(const void *in)
+{
+       const unsigned char *p = in;
+       return (uint32_t)(p[0]) << 16 |
+              (uint32_t)(p[1]) << 8 |
+              (uint32_t)(p[2]) << 0;
+}
+
+static inline uint32_t reftable_get_be32(const void *in)
+{
+       const unsigned char *p = in;
+       return (uint32_t)(p[0]) << 24 |
+              (uint32_t)(p[1]) << 16 |
+              (uint32_t)(p[2]) <<  8|
+              (uint32_t)(p[3]) <<  0;
+}
+
+static inline uint64_t reftable_get_be64(const void *in)
+{
+       const unsigned char *p = in;
+       return (uint64_t)(p[0]) << 56 |
+              (uint64_t)(p[1]) << 48 |
+              (uint64_t)(p[2]) << 40 |
+              (uint64_t)(p[3]) << 32 |
+              (uint64_t)(p[4]) << 24 |
+              (uint64_t)(p[5]) << 16 |
+              (uint64_t)(p[6]) <<  8 |
+              (uint64_t)(p[7]) <<  0;
+}
 
 /*
  * find smallest index i in [0, sz) at which `f(i) > 0`, assuming that f is

diff --git a/reftable/block.c b/reftable/block.c
index 999876826d1fd77f8df265409335c24bb9d20175..53b5e044690f52a0ec7b495ef01d093235b7640b 100644 (file)
--- a/reftable/block.c
+++ b/reftable/block.c
@@ -147,13 +147,13 @@ done:
 int block_writer_finish(struct block_writer *w)
 {
        for (uint32_t i = 0; i < w->restart_len; i++) {
-               put_be24(w->block + w->next, w->restarts[i]);
+               reftable_put_be24(w->block + w->next, w->restarts[i]);
                w->next += 3;
        }
 
-       put_be16(w->block + w->next, w->restart_len);
+       reftable_put_be16(w->block + w->next, w->restart_len);
        w->next += 2;
-       put_be24(w->block + 1 + w->header_off, w->next);
+       reftable_put_be24(w->block + 1 + w->header_off, w->next);
 
        /*
         * Log records are stored zlib-compressed. Note that the compression
@@ -215,7 +215,7 @@ int block_reader_init(struct block_reader *br, struct reftable_block *block,
 {
        uint32_t full_block_size = table_block_size;
        uint8_t typ = block->data[header_off];
-       uint32_t sz = get_be24(block->data + header_off + 1);
+       uint32_t sz = reftable_get_be24(block->data + header_off + 1);
        int err = 0;
        uint16_t restart_count = 0;
        uint32_t restart_start = 0;
@@ -299,7 +299,7 @@ int block_reader_init(struct block_reader *br, struct reftable_block *block,
                full_block_size = sz;
        }
 
-       restart_count = get_be16(block->data + sz - 2);
+       restart_count = reftable_get_be16(block->data + sz - 2);
        restart_start = sz - 2 - 3 * restart_count;
        restart_bytes = block->data + restart_start;
 
@@ -354,7 +354,7 @@ int block_reader_first_key(const struct block_reader *br, struct reftable_buf *k
 
 static uint32_t block_reader_restart_offset(const struct block_reader *br, size_t idx)
 {
-       return get_be24(br->restart_bytes + 3 * idx);
+       return reftable_get_be24(br->restart_bytes + 3 * idx);
 }
 
 void block_iter_seek_start(struct block_iter *it, const struct block_reader *br)

diff --git a/reftable/reader.c b/reftable/reader.c
index 36a5633eded9f3765f0dc891672fe7fe22c3fab0..bf07a0a586fd6ff13b969a388c39003d4d77f41a 100644 (file)
--- a/reftable/reader.c
+++ b/reftable/reader.c
@@ -101,18 +101,18 @@ static int parse_footer(struct reftable_reader *r, uint8_t *footer,
        }
 
        f++;
-       r->block_size = get_be24(f);
+       r->block_size = reftable_get_be24(f);
 
        f += 3;
-       r->min_update_index = get_be64(f);
+       r->min_update_index = reftable_get_be64(f);
        f += 8;
-       r->max_update_index = get_be64(f);
+       r->max_update_index = reftable_get_be64(f);
        f += 8;
 
        if (r->version == 1) {
                r->hash_id = REFTABLE_HASH_SHA1;
        } else {
-               switch (get_be32(f)) {
+               switch (reftable_get_be32(f)) {
                case REFTABLE_FORMAT_ID_SHA1:
                        r->hash_id = REFTABLE_HASH_SHA1;
                        break;
@@ -127,24 +127,24 @@ static int parse_footer(struct reftable_reader *r, uint8_t *footer,
                f += 4;
        }
 
-       r->ref_offsets.index_offset = get_be64(f);
+       r->ref_offsets.index_offset = reftable_get_be64(f);
        f += 8;
 
-       r->obj_offsets.offset = get_be64(f);
+       r->obj_offsets.offset = reftable_get_be64(f);
        f += 8;
 
        r->object_id_len = r->obj_offsets.offset & ((1 << 5) - 1);
        r->obj_offsets.offset >>= 5;
 
-       r->obj_offsets.index_offset = get_be64(f);
+       r->obj_offsets.index_offset = reftable_get_be64(f);
        f += 8;
-       r->log_offsets.offset = get_be64(f);
+       r->log_offsets.offset = reftable_get_be64(f);
        f += 8;
-       r->log_offsets.index_offset = get_be64(f);
+       r->log_offsets.index_offset = reftable_get_be64(f);
        f += 8;
 
        computed_crc = crc32(0, footer, f - footer);
-       file_crc = get_be32(f);
+       file_crc = reftable_get_be32(f);
        f += 4;
        if (computed_crc != file_crc) {
                err = REFTABLE_FORMAT_ERROR;
@@ -214,7 +214,7 @@ static int32_t extract_block_size(uint8_t *data, uint8_t *typ, uint64_t off,
 
        *typ = data[0];
        if (reftable_is_block_type(*typ)) {
-               result = get_be24(data + 1);
+               result = reftable_get_be24(data + 1);
        }
        return result;
 }

diff --git a/reftable/record.c b/reftable/record.c
index b39d99fcc75a66b55de225699b416ffa3381c4ec..3552bafa9945ebce90e34f6d94f69867f47e9227 100644 (file)
--- a/reftable/record.c
+++ b/reftable/record.c
@@ -689,7 +689,7 @@ static int reftable_log_record_key(const void *r, struct reftable_buf *dest)
                return err;
 
        ts = (~ts) - rec->update_index;
-       put_be64(&i64[0], ts);
+       reftable_put_be64(&i64[0], ts);
 
        err = reftable_buf_add(dest, i64, sizeof(i64));
        if (err < 0)
@@ -814,7 +814,7 @@ static int reftable_log_record_encode(const void *rec, struct string_view s,
        if (s.len < 2)
                return -1;
 
-       put_be16(s.buf, r->value.update.tz_offset);
+       reftable_put_be16(s.buf, r->value.update.tz_offset);
        string_view_consume(&s, 2);
 
        n = encode_string(
@@ -846,7 +846,7 @@ static int reftable_log_record_decode(void *rec, struct reftable_buf key,
        }
 
        memcpy(r->refname, key.buf, key.len - 8);
-       ts = get_be64(key.buf + key.len - 8);
+       ts = reftable_get_be64((unsigned char *)key.buf + key.len - 8);
 
        r->update_index = (~max) - ts;
 
@@ -937,7 +937,7 @@ static int reftable_log_record_decode(void *rec, struct reftable_buf key,
                goto done;
        }
 
-       r->value.update.tz_offset = get_be16(in.buf);
+       r->value.update.tz_offset = reftable_get_be16(in.buf);
        string_view_consume(&in, 2);
 
        n = decode_string(scratch, in);

diff --git a/reftable/writer.c b/reftable/writer.c
index 239573ade245068a67b5bf6972bb61a07bb86e5e..913b971b591eb4f99ab5277040fe7fcd18c02e10 100644 (file)
--- a/reftable/writer.c
+++ b/reftable/writer.c
@@ -99,9 +99,9 @@ static int writer_write_header(struct reftable_writer *w, uint8_t *dest)
 
        dest[4] = writer_version(w);
 
-       put_be24(dest + 5, w->opts.block_size);
-       put_be64(dest + 8, w->min_update_index);
-       put_be64(dest + 16, w->max_update_index);
+       reftable_put_be24(dest + 5, w->opts.block_size);
+       reftable_put_be64(dest + 8, w->min_update_index);
+       reftable_put_be64(dest + 16, w->max_update_index);
        if (writer_version(w) == 2) {
                uint32_t hash_id;
 
@@ -116,7 +116,7 @@ static int writer_write_header(struct reftable_writer *w, uint8_t *dest)
                        return -1;
                }
 
-               put_be32(dest + 24, hash_id);
+               reftable_put_be32(dest + 24, hash_id);
        }
 
        return header_size(writer_version(w));
@@ -730,19 +730,19 @@ int reftable_writer_close(struct reftable_writer *w)
        }
 
        p += writer_write_header(w, footer);
-       put_be64(p, w->stats.ref_stats.index_offset);
+       reftable_put_be64(p, w->stats.ref_stats.index_offset);
        p += 8;
-       put_be64(p, (w->stats.obj_stats.offset) << 5 | w->stats.object_id_len);
+       reftable_put_be64(p, (w->stats.obj_stats.offset) << 5 | w->stats.object_id_len);
        p += 8;
-       put_be64(p, w->stats.obj_stats.index_offset);
+       reftable_put_be64(p, w->stats.obj_stats.index_offset);
        p += 8;
 
-       put_be64(p, w->stats.log_stats.offset);
+       reftable_put_be64(p, w->stats.log_stats.offset);
        p += 8;
-       put_be64(p, w->stats.log_stats.index_offset);
+       reftable_put_be64(p, w->stats.log_stats.index_offset);
        p += 8;
 
-       put_be32(p, crc32(0, footer, p - footer));
+       reftable_put_be32(p, crc32(0, footer, p - footer));
        p += 4;
 
        err = w->flush(w->write_arg);

diff --git a/t/unit-tests/t-reftable-basics.c b/t/unit-tests/t-reftable-basics.c
index 9ba7eb05ada89b92d9499c7ec5f47e96a5a35895..c9e751e49e9aae1b2bf44a7718160100fbc4c5c0 100644 (file)
--- a/t/unit-tests/t-reftable-basics.c
+++ b/t/unit-tests/t-reftable-basics.c
@@ -128,12 +128,30 @@ int cmd_main(int argc UNUSED, const char *argv[] UNUSED)
                reftable_buf_release(&b);
        }
 
-       if_test ("put_be24 and get_be24 work") {
+       if_test ("reftable_put_be64 and reftable_get_be64 work") {
+               uint64_t in = 0x1122334455667788;
+               uint8_t dest[8];
+               uint64_t out;
+               reftable_put_be64(dest, in);
+               out = reftable_get_be64(dest);
+               check_int(in, ==, out);
+       }
+
+       if_test ("reftable_put_be32 and reftable_get_be32 work") {
+               uint32_t in = 0x11223344;
+               uint8_t dest[4];
+               uint32_t out;
+               reftable_put_be32(dest, in);
+               out = reftable_get_be32(dest);
+               check_int(in, ==, out);
+       }
+
+       if_test ("reftable_put_be24 and reftable_get_be24 work") {
                uint32_t in = 0x112233;
                uint8_t dest[3];
                uint32_t out;
-               put_be24(dest, in);
-               out = get_be24(dest);
+               reftable_put_be24(dest, in);
+               out = reftable_get_be24(dest);
                check_int(in, ==, out);
        }
 
@@ -141,8 +159,8 @@ int cmd_main(int argc UNUSED, const char *argv[] UNUSED)
                uint32_t in = 0xfef1;
                uint8_t dest[3];
                uint32_t out;
-               put_be16(dest, in);
-               out = get_be16(dest);
+               reftable_put_be16(dest, in);
+               out = reftable_get_be16(dest);
                check_int(in, ==, out);
        }