@matheusbsbs / matheus-bagliano / commits / e676694298

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>

Patrick Steinhardt committed Feb 18, 2025 at 10:20 UTC e676694298c4a8d9f6fdf3844cbfb03bbee552cc

7 files changed +127 -58

reftable/basics.c

-19

@@ -147,25 +147,6 @@ char *reftable_buf_detach(struct reftable_buf *buf)

147 return result;

148 }

149

150 -void put_be24(uint8_t *out, uint32_t i)

151 -{

152 - out[0] = (uint8_t)((i >> 16) & 0xff);

153 - out[1] = (uint8_t)((i >> 8) & 0xff);

154 - out[2] = (uint8_t)(i & 0xff);

155 -}

156 -

157 -uint32_t get_be24(uint8_t *in)

158 -{

159 - return (uint32_t)(in[0]) << 16 | (uint32_t)(in[1]) << 8 |

160 - (uint32_t)(in[2]);

161 -}

162 -

163 -void put_be16(uint8_t *out, uint16_t i)

164 -{

165 - out[0] = (uint8_t)((i >> 8) & 0xff);

166 - out[1] = (uint8_t)(i & 0xff);

167 -}

168 -

150 size_t binsearch(size_t sz, int (*f)(size_t k, void *args), void *args)

151 {

152 size_t lo = 0;

reftable/basics.h

+73 -3

@@ -76,9 +76,79 @@ char *reftable_buf_detach(struct reftable_buf *buf);

77 /* Bigendian en/decoding of integers */

79 -void put_be24(uint8_t *out, uint32_t i);

80 -uint32_t get_be24(uint8_t *in);

81 -void put_be16(uint8_t *out, uint16_t i);

79 +static inline void reftable_put_be16(void *out, uint16_t i)

80 +{

81 + unsigned char *p = out;

82 + p[0] = (uint8_t)((i >> 8) & 0xff);

83 + p[1] = (uint8_t)((i >> 0) & 0xff);

84 +}

85 +

86 +static inline void reftable_put_be24(void *out, uint32_t i)

87 +{

88 + unsigned char *p = out;

89 + p[0] = (uint8_t)((i >> 16) & 0xff);

90 + p[1] = (uint8_t)((i >> 8) & 0xff);

91 + p[2] = (uint8_t)((i >> 0) & 0xff);

92 +}

93 +

94 +static inline void reftable_put_be32(void *out, uint32_t i)

95 +{

96 + unsigned char *p = out;

97 + p[0] = (uint8_t)((i >> 24) & 0xff);

98 + p[1] = (uint8_t)((i >> 16) & 0xff);

99 + p[2] = (uint8_t)((i >> 8) & 0xff);

100 + p[3] = (uint8_t)((i >> 0) & 0xff);

101 +}

102 +

103 +static inline void reftable_put_be64(void *out, uint64_t i)

104 +{

105 + unsigned char *p = out;

106 + p[0] = (uint8_t)((i >> 56) & 0xff);

107 + p[1] = (uint8_t)((i >> 48) & 0xff);

108 + p[2] = (uint8_t)((i >> 40) & 0xff);

109 + p[3] = (uint8_t)((i >> 32) & 0xff);

110 + p[4] = (uint8_t)((i >> 24) & 0xff);

111 + p[5] = (uint8_t)((i >> 16) & 0xff);

112 + p[6] = (uint8_t)((i >> 8) & 0xff);

113 + p[7] = (uint8_t)((i >> 0) & 0xff);

114 +}

115 +

116 +static inline uint16_t reftable_get_be16(const void *in)

117 +{

118 + const unsigned char *p = in;

119 + return (uint16_t)(p[0]) << 8 |

120 + (uint16_t)(p[1]) << 0;

121 +}

122 +

123 +static inline uint32_t reftable_get_be24(const void *in)

124 +{

125 + const unsigned char *p = in;

126 + return (uint32_t)(p[0]) << 16 |

127 + (uint32_t)(p[1]) << 8 |

128 + (uint32_t)(p[2]) << 0;

129 +}

130 +

131 +static inline uint32_t reftable_get_be32(const void *in)

132 +{

133 + const unsigned char *p = in;

134 + return (uint32_t)(p[0]) << 24 |

135 + (uint32_t)(p[1]) << 16 |

136 + (uint32_t)(p[2]) << 8|

137 + (uint32_t)(p[3]) << 0;

138 +}

139 +

140 +static inline uint64_t reftable_get_be64(const void *in)

141 +{

142 + const unsigned char *p = in;

143 + return (uint64_t)(p[0]) << 56 |

144 + (uint64_t)(p[1]) << 48 |

145 + (uint64_t)(p[2]) << 40 |

146 + (uint64_t)(p[3]) << 32 |

147 + (uint64_t)(p[4]) << 24 |

148 + (uint64_t)(p[5]) << 16 |

149 + (uint64_t)(p[6]) << 8 |

150 + (uint64_t)(p[7]) << 0;

151 +}

152

153 /*

154 * find smallest index i in [0, sz) at which `f(i) > 0`, assuming that f is

reftable/block.c

+6 -6

@@ -147,13 +147,13 @@ done:

147 int block_writer_finish(struct block_writer *w)

148 {

149 for (uint32_t i = 0; i < w->restart_len; i++) {

150 - put_be24(w->block + w->next, w->restarts[i]);

150 + reftable_put_be24(w->block + w->next, w->restarts[i]);

151 w->next += 3;

152 }

153

154 - put_be16(w->block + w->next, w->restart_len);

154 + reftable_put_be16(w->block + w->next, w->restart_len);

155 w->next += 2;

156 - put_be24(w->block + 1 + w->header_off, w->next);

156 + reftable_put_be24(w->block + 1 + w->header_off, w->next);

157

158 /*

159 * 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,

215 {

216 uint32_t full_block_size = table_block_size;

217 uint8_t typ = block->data[header_off];

218 - uint32_t sz = get_be24(block->data + header_off + 1);

218 + uint32_t sz = reftable_get_be24(block->data + header_off + 1);

219 int err = 0;

220 uint16_t restart_count = 0;

221 uint32_t restart_start = 0;

@@ -299,7 +299,7 @@ int block_reader_init(struct block_reader *br, struct reftable_block *block,

299 full_block_size = sz;

300 }

301

302 - restart_count = get_be16(block->data + sz - 2);

302 + restart_count = reftable_get_be16(block->data + sz - 2);

303 restart_start = sz - 2 - 3 * restart_count;

304 restart_bytes = block->data + restart_start;

305

@@ -354,7 +354,7 @@ int block_reader_first_key(const struct block_reader *br, struct reftable_buf *k

354

355 static uint32_t block_reader_restart_offset(const struct block_reader *br, size_t idx)

356 {

357 - return get_be24(br->restart_bytes + 3 * idx);

357 + return reftable_get_be24(br->restart_bytes + 3 * idx);

358 }

359

360 void block_iter_seek_start(struct block_iter *it, const struct block_reader *br)

reftable/reader.c

+11 -11

@@ -101,18 +101,18 @@ static int parse_footer(struct reftable_reader *r, uint8_t *footer,

101 }

102

103 f++;

104 - r->block_size = get_be24(f);

104 + r->block_size = reftable_get_be24(f);

105

106 f += 3;

107 - r->min_update_index = get_be64(f);

107 + r->min_update_index = reftable_get_be64(f);

108 f += 8;

109 - r->max_update_index = get_be64(f);

109 + r->max_update_index = reftable_get_be64(f);

110 f += 8;

111

112 if (r->version == 1) {

113 r->hash_id = REFTABLE_HASH_SHA1;

114 } else {

115 - switch (get_be32(f)) {

115 + switch (reftable_get_be32(f)) {

116 case REFTABLE_FORMAT_ID_SHA1:

117 r->hash_id = REFTABLE_HASH_SHA1;

118 break;

@@ -127,24 +127,24 @@ static int parse_footer(struct reftable_reader *r, uint8_t *footer,

127 f += 4;

128 }

129

130 - r->ref_offsets.index_offset = get_be64(f);

130 + r->ref_offsets.index_offset = reftable_get_be64(f);

131 f += 8;

132

133 - r->obj_offsets.offset = get_be64(f);

133 + r->obj_offsets.offset = reftable_get_be64(f);

134 f += 8;

135

136 r->object_id_len = r->obj_offsets.offset & ((1 << 5) - 1);

137 r->obj_offsets.offset >>= 5;

138

139 - r->obj_offsets.index_offset = get_be64(f);

139 + r->obj_offsets.index_offset = reftable_get_be64(f);

140 f += 8;

141 - r->log_offsets.offset = get_be64(f);

141 + r->log_offsets.offset = reftable_get_be64(f);

142 f += 8;

143 - r->log_offsets.index_offset = get_be64(f);

143 + r->log_offsets.index_offset = reftable_get_be64(f);

144 f += 8;

145

146 computed_crc = crc32(0, footer, f - footer);

147 - file_crc = get_be32(f);

147 + file_crc = reftable_get_be32(f);

148 f += 4;

149 if (computed_crc != file_crc) {

150 err = REFTABLE_FORMAT_ERROR;

@@ -214,7 +214,7 @@ static int32_t extract_block_size(uint8_t *data, uint8_t *typ, uint64_t off,

214

215 *typ = data[0];

216 if (reftable_is_block_type(*typ)) {

217 - result = get_be24(data + 1);

217 + result = reftable_get_be24(data + 1);

218 }

219 return result;

220 }

reftable/record.c

+4 -4

@@ -689,7 +689,7 @@ static int reftable_log_record_key(const void *r, struct reftable_buf *dest)

689 return err;

690

691 ts = (~ts) - rec->update_index;

692 - put_be64(&i64[0], ts);

692 + reftable_put_be64(&i64[0], ts);

693

694 err = reftable_buf_add(dest, i64, sizeof(i64));

695 if (err < 0)

@@ -814,7 +814,7 @@ static int reftable_log_record_encode(const void *rec, struct string_view s,

814 if (s.len < 2)

815 return -1;

816

817 - put_be16(s.buf, r->value.update.tz_offset);

817 + reftable_put_be16(s.buf, r->value.update.tz_offset);

818 string_view_consume(&s, 2);

819

820 n = encode_string(

@@ -846,7 +846,7 @@ static int reftable_log_record_decode(void *rec, struct reftable_buf key,

846 }

847

848 memcpy(r->refname, key.buf, key.len - 8);

849 - ts = get_be64(key.buf + key.len - 8);

849 + ts = reftable_get_be64((unsigned char *)key.buf + key.len - 8);

850

851 r->update_index = (~max) - ts;

852

@@ -937,7 +937,7 @@ static int reftable_log_record_decode(void *rec, struct reftable_buf key,

937 goto done;

938 }

939

940 - r->value.update.tz_offset = get_be16(in.buf);

940 + r->value.update.tz_offset = reftable_get_be16(in.buf);

941 string_view_consume(&in, 2);

942

943 n = decode_string(scratch, in);

reftable/writer.c

+10 -10

@@ -99,9 +99,9 @@ static int writer_write_header(struct reftable_writer *w, uint8_t *dest)

100 dest[4] = writer_version(w);

101

102 - put_be24(dest + 5, w->opts.block_size);

103 - put_be64(dest + 8, w->min_update_index);

104 - put_be64(dest + 16, w->max_update_index);

102 + reftable_put_be24(dest + 5, w->opts.block_size);

103 + reftable_put_be64(dest + 8, w->min_update_index);

104 + reftable_put_be64(dest + 16, w->max_update_index);

105 if (writer_version(w) == 2) {

106 uint32_t hash_id;

107

@@ -116,7 +116,7 @@ static int writer_write_header(struct reftable_writer *w, uint8_t *dest)

116 return -1;

117 }

118

119 - put_be32(dest + 24, hash_id);

119 + reftable_put_be32(dest + 24, hash_id);

120 }

121

122 return header_size(writer_version(w));

@@ -730,19 +730,19 @@ int reftable_writer_close(struct reftable_writer *w)

730 }

731

732 p += writer_write_header(w, footer);

733 - put_be64(p, w->stats.ref_stats.index_offset);

733 + reftable_put_be64(p, w->stats.ref_stats.index_offset);

734 p += 8;

735 - put_be64(p, (w->stats.obj_stats.offset) << 5 | w->stats.object_id_len);

735 + reftable_put_be64(p, (w->stats.obj_stats.offset) << 5 | w->stats.object_id_len);

736 p += 8;

737 - put_be64(p, w->stats.obj_stats.index_offset);

737 + reftable_put_be64(p, w->stats.obj_stats.index_offset);

738 p += 8;

739

740 - put_be64(p, w->stats.log_stats.offset);

740 + reftable_put_be64(p, w->stats.log_stats.offset);

741 p += 8;

742 - put_be64(p, w->stats.log_stats.index_offset);

742 + reftable_put_be64(p, w->stats.log_stats.index_offset);

743 p += 8;

744

745 - put_be32(p, crc32(0, footer, p - footer));

745 + reftable_put_be32(p, crc32(0, footer, p - footer));

746 p += 4;

747

748 err = w->flush(w->write_arg);

t/unit-tests/t-reftable-basics.c

+23 -5

@@ -128,12 +128,30 @@ int cmd_main(int argc UNUSED, const char *argv[] UNUSED)

128 reftable_buf_release(&b);

129 }

130

131 - if_test ("put_be24 and get_be24 work") {

131 + if_test ("reftable_put_be64 and reftable_get_be64 work") {

132 + uint64_t in = 0x1122334455667788;

133 + uint8_t dest[8];

134 + uint64_t out;

135 + reftable_put_be64(dest, in);

136 + out = reftable_get_be64(dest);

137 + check_int(in, ==, out);

138 + }

139 +

140 + if_test ("reftable_put_be32 and reftable_get_be32 work") {

141 + uint32_t in = 0x11223344;

142 + uint8_t dest[4];

143 + uint32_t out;

144 + reftable_put_be32(dest, in);

145 + out = reftable_get_be32(dest);

146 + check_int(in, ==, out);

147 + }

148 +

149 + if_test ("reftable_put_be24 and reftable_get_be24 work") {

150 uint32_t in = 0x112233;

151 uint8_t dest[3];

152 uint32_t out;

135 - put_be24(dest, in);

136 - out = get_be24(dest);

153 + reftable_put_be24(dest, in);

154 + out = reftable_get_be24(dest);

155 check_int(in, ==, out);

156 }

157

@@ -141,8 +159,8 @@ int cmd_main(int argc UNUSED, const char *argv[] UNUSED)

159 uint32_t in = 0xfef1;

160 uint8_t dest[3];

161 uint32_t out;

144 - put_be16(dest, in);

145 - out = get_be16(dest);

162 + reftable_put_be16(dest, in);

163 + out = reftable_get_be16(dest);

164 check_int(in, ==, out);

165 }

166