@matheusbsbs / matheus-bagliano / commits / 20590cd287

reftable: handle trivial `reftable_buf` errors

Convert the reftable library such that we handle failures with the new `reftable_buf` interfaces. Signed-off-by: Patrick Steinhardt <ps@pks.im> Signed-off-by: Taylor Blau <me@ttaylorr.com>

Patrick Steinhardt committed Oct 17, 2024 at 06:54 UTC 20590cd287ada9c96efdf804e2bcdac0117c01b8
6 files changed +107 -41
reftable/block.c
+7 -2
@@ -40,7 +40,9 @@ int footer_size(int version)
40 static int block_writer_register_restart(struct block_writer *w, int n,
41 int is_restart, struct reftable_buf *key)
42 {
43 - int rlen = w->restart_len;
43 + int rlen, err;
44 +
45 + rlen = w->restart_len;
46 if (rlen >= MAX_RESTARTS) {
47 is_restart = 0;
48 }
@@ -60,7 +62,10 @@ static int block_writer_register_restart(struct block_writer *w, int n,
62 w->next += n;
63
64 reftable_buf_reset(&w->last_key);
63 - reftable_buf_add(&w->last_key, key->buf, key->len);
65 + err = reftable_buf_add(&w->last_key, key->buf, key->len);
66 + if (err < 0)
67 + return err;
68 +
69 w->entries++;
70 return 0;
71 }
reftable/iter.c
+4 -1
@@ -197,7 +197,10 @@ int indexed_table_ref_iter_new(struct indexed_table_ref_iter **dest,
197
198 *itr = empty;
199 itr->r = r;
200 - reftable_buf_add(&itr->oid, oid, oid_len);
200 +
201 + err = reftable_buf_add(&itr->oid, oid, oid_len);
202 + if (err < 0)
203 + goto out;
204
205 itr->offsets = offsets;
206 itr->offset_len = offset_len;
reftable/reader.c
+4 -1
@@ -769,7 +769,10 @@ static int reftable_reader_refs_for_unindexed(struct reftable_reader *r,
769 }
770 *filter = empty;
771
772 - reftable_buf_add(&filter->oid, oid, oid_len);
772 + err = reftable_buf_add(&filter->oid, oid, oid_len);
773 + if (err < 0)
774 + goto out;
775 +
776 iterator_from_table_iter(&filter->it, ti);
777
778 iterator_from_filtering_ref_iterator(it, filter);
reftable/record.c
+24 -8
@@ -102,7 +102,9 @@ static int decode_string(struct reftable_buf *dest, struct string_view in)
102 {
103 int start_len = in.len;
104 uint64_t tsize = 0;
105 - int n = get_var_int(&tsize, &in);
105 + int n, err;
106 +
107 + n = get_var_int(&tsize, &in);
108 if (n <= 0)
109 return -1;
110 string_view_consume(&in, n);
@@ -110,7 +112,10 @@ static int decode_string(struct reftable_buf *dest, struct string_view in)
112 return -1;
113
114 reftable_buf_reset(dest);
113 - reftable_buf_add(dest, in.buf, tsize);
115 + err = reftable_buf_add(dest, in.buf, tsize);
116 + if (err < 0)
117 + return err;
118 +
119 string_view_consume(&in, tsize);
120
121 return start_len - in.len;
@@ -189,7 +194,7 @@ int reftable_decode_key(struct reftable_buf *last_key, uint8_t *extra,
194 int start_len = in.len;
195 uint64_t prefix_len = 0;
196 uint64_t suffix_len = 0;
192 - int n;
197 + int err, n;
198
199 n = reftable_decode_keylen(in, &prefix_len, &suffix_len, extra);
200 if (n < 0)
@@ -200,8 +205,14 @@ int reftable_decode_key(struct reftable_buf *last_key, uint8_t *extra,
205 prefix_len > last_key->len)
206 return -1;
207
203 - reftable_buf_setlen(last_key, prefix_len);
204 - reftable_buf_add(last_key, in.buf, suffix_len);
208 + err = reftable_buf_setlen(last_key, prefix_len);
209 + if (err < 0)
210 + return err;
211 +
212 + err = reftable_buf_add(last_key, in.buf, suffix_len);
213 + if (err < 0)
214 + return err;
215 +
216 string_view_consume(&in, suffix_len);
217
218 return start_len - in.len;
@@ -1047,9 +1058,12 @@ static int reftable_index_record_copy_from(void *rec, const void *src_rec,
1058 {
1059 struct reftable_index_record *dst = rec;
1060 const struct reftable_index_record *src = src_rec;
1061 + int err;
1062
1063 reftable_buf_reset(&dst->last_key);
1052 - reftable_buf_add(&dst->last_key, src->last_key.buf, src->last_key.len);
1064 + err = reftable_buf_add(&dst->last_key, src->last_key.buf, src->last_key.len);
1065 + if (err < 0)
1066 + return err;
1067 dst->offset = src->offset;
1068
1069 return 0;
@@ -1090,10 +1104,12 @@ static int reftable_index_record_decode(void *rec, struct reftable_buf key,
1104 {
1105 struct string_view start = in;
1106 struct reftable_index_record *r = rec;
1093 - int n = 0;
1107 + int err, n = 0;
1108
1109 reftable_buf_reset(&r->last_key);
1096 - reftable_buf_add(&r->last_key, key.buf, key.len);
1110 + err = reftable_buf_add(&r->last_key, key.buf, key.len);
1111 + if (err < 0)
1112 + return err;
1113
1114 n = get_var_int(&r->offset, &in);
1115 if (n < 0)
reftable/stack.c
+33 -16
@@ -78,8 +78,9 @@ int reftable_new_stack(struct reftable_stack **dest, const char *dir,
78 *dest = NULL;
79
80 reftable_buf_reset(&list_file_name);
81 - reftable_buf_addstr(&list_file_name, dir);
82 - reftable_buf_addstr(&list_file_name, "/tables.list");
81 + if ((err = reftable_buf_addstr(&list_file_name, dir)) < 0 ||
82 + (err = reftable_buf_addstr(&list_file_name, "/tables.list")) < 0)
83 + goto out;
84
85 p->list_file = reftable_buf_detach(&list_file_name);
86 p->list_fd = -1;
@@ -747,12 +748,14 @@ int reftable_addition_commit(struct reftable_addition *add)
748 goto done;
749
750 for (i = 0; i < add->stack->merged->readers_len; i++) {
750 - reftable_buf_addstr(&table_list, add->stack->readers[i]->name);
751 - reftable_buf_addstr(&table_list, "\n");
751 + if ((err = reftable_buf_addstr(&table_list, add->stack->readers[i]->name)) < 0 ||
752 + (err = reftable_buf_addstr(&table_list, "\n")) < 0)
753 + goto done;
754 }
755 for (i = 0; i < add->new_tables_len; i++) {
754 - reftable_buf_addstr(&table_list, add->new_tables[i]);
755 - reftable_buf_addstr(&table_list, "\n");
756 + if ((err = reftable_buf_addstr(&table_list, add->new_tables[i])) < 0 ||
757 + (err = reftable_buf_addstr(&table_list, "\n")) < 0)
758 + goto done;
759 }
760
761 err = write_in_full(lock_file_fd, table_list.buf, table_list.len);
@@ -867,7 +870,10 @@ int reftable_addition_add(struct reftable_addition *add,
870 err = stack_filename(&temp_tab_file_name, add->stack, next_name.buf);
871 if (err < 0)
872 goto done;
870 - reftable_buf_addstr(&temp_tab_file_name, ".temp.XXXXXX");
873 +
874 + err = reftable_buf_addstr(&temp_tab_file_name, ".temp.XXXXXX");
875 + if (err < 0)
876 + goto done;
877
878 tab_file = mks_tempfile(temp_tab_file_name.buf);
879 if (!tab_file) {
@@ -914,7 +920,10 @@ int reftable_addition_add(struct reftable_addition *add,
920 err = format_name(&next_name, wr->min_update_index, wr->max_update_index);
921 if (err < 0)
922 goto done;
917 - reftable_buf_addstr(&next_name, ".ref");
923 +
924 + err = reftable_buf_addstr(&next_name, ".ref");
925 + if (err < 0)
926 + goto done;
927
928 err = stack_filename(&tab_file_name, add->stack, next_name.buf);
929 if (err < 0)
@@ -975,7 +984,10 @@ static int stack_compact_locked(struct reftable_stack *st,
984 err = stack_filename(&tab_file_path, st, next_name.buf);
985 if (err < 0)
986 goto done;
978 - reftable_buf_addstr(&tab_file_path, ".temp.XXXXXX");
987 +
988 + err = reftable_buf_addstr(&tab_file_path, ".temp.XXXXXX");
989 + if (err < 0)
990 + goto done;
991
992 tab_file = mks_tempfile(tab_file_path.buf);
993 if (!tab_file) {
@@ -1404,7 +1416,9 @@ static int stack_compact_range(struct reftable_stack *st,
1416 if (err < 0)
1417 goto done;
1418
1407 - reftable_buf_addstr(&new_table_name, ".ref");
1419 + err = reftable_buf_addstr(&new_table_name, ".ref");
1420 + if (err < 0)
1421 + goto done;
1422
1423 err = stack_filename(&new_table_path, st, new_table_name.buf);
1424 if (err < 0)
@@ -1423,16 +1437,19 @@ static int stack_compact_range(struct reftable_stack *st,
1437 * simply skip writing it.
1438 */
1439 for (i = 0; i < first_to_replace; i++) {
1426 - reftable_buf_addstr(&tables_list_buf, names[i]);
1427 - reftable_buf_addstr(&tables_list_buf, "\n");
1440 + if ((err = reftable_buf_addstr(&tables_list_buf, names[i])) < 0 ||
1441 + (err = reftable_buf_addstr(&tables_list_buf, "\n")) < 0)
1442 + goto done;
1443 }
1444 if (!is_empty_table) {
1430 - reftable_buf_addstr(&tables_list_buf, new_table_name.buf);
1431 - reftable_buf_addstr(&tables_list_buf, "\n");
1445 + if ((err = reftable_buf_addstr(&tables_list_buf, new_table_name.buf)) < 0 ||
1446 + (err = reftable_buf_addstr(&tables_list_buf, "\n")) < 0)
1447 + goto done;
1448 }
1449 for (i = last_to_replace + 1; names[i]; i++) {
1434 - reftable_buf_addstr(&tables_list_buf, names[i]);
1435 - reftable_buf_addstr(&tables_list_buf, "\n");
1450 + if ((err = reftable_buf_addstr(&tables_list_buf, names[i])) < 0 ||
1451 + (err = reftable_buf_addstr(&tables_list_buf, "\n")) < 0)
1452 + goto done;
1453 }
1454
1455 err = write_in_full(get_lock_file_fd(&tables_list_lock),
reftable/writer.c
+35 -13
@@ -217,6 +217,7 @@ static int writer_index_hash(struct reftable_writer *w, struct reftable_buf *has
217 node = tree_search(w->obj_index_tree, &want, &obj_index_tree_node_compare);
218 if (!node) {
219 struct obj_index_tree_node empty = OBJ_INDEX_TREE_NODE_INIT;
220 + int err;
221
222 key = reftable_malloc(sizeof(*key));
223 if (!key)
@@ -225,7 +226,9 @@ static int writer_index_hash(struct reftable_writer *w, struct reftable_buf *has
226 *key = empty;
227
228 reftable_buf_reset(&key->hash);
228 - reftable_buf_add(&key->hash, hash->buf, hash->len);
229 + err = reftable_buf_add(&key->hash, hash->buf, hash->len);
230 + if (err < 0)
231 + return err;
232 tree_insert(&w->obj_index_tree, key,
233 &obj_index_tree_node_compare);
234 } else {
@@ -259,7 +262,10 @@ static int writer_add_record(struct reftable_writer *w,
262 }
263
264 reftable_buf_reset(&w->last_key);
262 - reftable_buf_add(&w->last_key, key.buf, key.len);
265 + err = reftable_buf_add(&w->last_key, key.buf, key.len);
266 + if (err < 0)
267 + goto done;
268 +
269 if (!w->block_writer) {
270 err = writer_reinit_block_writer(w, reftable_record_type(rec));
271 if (err < 0)
@@ -334,8 +340,10 @@ int reftable_writer_add_ref(struct reftable_writer *w,
340 goto out;
341
342 if (!w->opts.skip_index_objects && reftable_ref_record_val1(ref)) {
337 - reftable_buf_add(&buf, (char *)reftable_ref_record_val1(ref),
338 - hash_size(w->opts.hash_id));
343 + err = reftable_buf_add(&buf, (char *)reftable_ref_record_val1(ref),
344 + hash_size(w->opts.hash_id));
345 + if (err < 0)
346 + goto out;
347
348 err = writer_index_hash(w, &buf);
349 if (err < 0)
@@ -344,8 +352,10 @@ int reftable_writer_add_ref(struct reftable_writer *w,
352
353 if (!w->opts.skip_index_objects && reftable_ref_record_val2(ref)) {
354 reftable_buf_reset(&buf);
347 - reftable_buf_add(&buf, reftable_ref_record_val2(ref),
348 - hash_size(w->opts.hash_id));
355 + err = reftable_buf_add(&buf, reftable_ref_record_val2(ref),
356 + hash_size(w->opts.hash_id));
357 + if (err < 0)
358 + goto out;
359
360 err = writer_index_hash(w, &buf);
361 if (err < 0)
@@ -407,17 +417,27 @@ int reftable_writer_add_log(struct reftable_writer *w,
417
418 input_log_message = log->value.update.message;
419 if (!w->opts.exact_log_message && log->value.update.message) {
410 - reftable_buf_addstr(&cleaned_message, log->value.update.message);
420 + err = reftable_buf_addstr(&cleaned_message, log->value.update.message);
421 + if (err < 0)
422 + goto done;
423 +
424 while (cleaned_message.len &&
412 - cleaned_message.buf[cleaned_message.len - 1] == '\n')
413 - reftable_buf_setlen(&cleaned_message,
414 - cleaned_message.len - 1);
425 + cleaned_message.buf[cleaned_message.len - 1] == '\n') {
426 + err = reftable_buf_setlen(&cleaned_message,
427 + cleaned_message.len - 1);
428 + if (err < 0)
429 + goto done;
430 + }
431 if (strchr(cleaned_message.buf, '\n')) {
432 /* multiple lines not allowed. */
433 err = REFTABLE_API_ERROR;
434 goto done;
435 }
420 - reftable_buf_addstr(&cleaned_message, "\n");
436 +
437 + err = reftable_buf_addstr(&cleaned_message, "\n");
438 + if (err < 0)
439 + goto done;
440 +
441 log->value.update.message = cleaned_message.buf;
442 }
443
@@ -781,8 +801,10 @@ static int writer_flush_nonempty_block(struct reftable_writer *w)
801
802 index_record.offset = w->next;
803 reftable_buf_reset(&index_record.last_key);
784 - reftable_buf_add(&index_record.last_key, w->block_writer->last_key.buf,
785 - w->block_writer->last_key.len);
804 + err = reftable_buf_add(&index_record.last_key, w->block_writer->last_key.buf,
805 + w->block_writer->last_key.len);
806 + if (err < 0)
807 + return err;
808 w->index[w->index_len] = index_record;
809 w->index_len++;
810