reftable/iter.c

   1 /*
   2 Copyright 2020 Google LLC
   3
   4 Use of this source code is governed by a BSD-style
   5 license that can be found in the LICENSE file or at
   6 https://developers.google.com/open-source/licenses/bsd
   7 */
   8
   9 #include "iter.h"
  10
  11 #include "system.h"
  12
  13 #include "block.h"
  14 #include "constants.h"
  15 #include "reader.h"
  16 #include "reftable-error.h"
  17
  18 int iterator_seek(struct reftable_iterator *it, struct reftable_record *want)
  19 {
  20         return it->ops->seek(it->iter_arg, want);
  21 }
  22
  23 int iterator_next(struct reftable_iterator *it, struct reftable_record *rec)
  24 {
  25         return it->ops->next(it->iter_arg, rec);
  26 }
  27
  28 static int empty_iterator_seek(void *arg UNUSED, struct reftable_record *want UNUSED)
  29 {
  30         return 0;
  31 }
  32
  33 static int empty_iterator_next(void *arg UNUSED, struct reftable_record *rec UNUSED)
  34 {
  35         return 1;
  36 }
  37
  38 static void empty_iterator_close(void *arg UNUSED)
  39 {
  40 }
  41
  42 static struct reftable_iterator_vtable empty_vtable = {
  43         .seek = &empty_iterator_seek,
  44         .next = &empty_iterator_next,
  45         .close = &empty_iterator_close,
  46 };
  47
  48 void iterator_set_empty(struct reftable_iterator *it)
  49 {
  50         assert(!it->ops);
  51         it->iter_arg = NULL;
  52         it->ops = &empty_vtable;
  53 }
  54
  55 static void filtering_ref_iterator_close(void *iter_arg)
  56 {
  57         struct filtering_ref_iterator *fri = iter_arg;
  58         strbuf_release(&fri->oid);
  59         reftable_iterator_destroy(&fri->it);
  60 }
  61
  62 static int filtering_ref_iterator_seek(void *iter_arg,
  63                                        struct reftable_record *want)
  64 {
  65         struct filtering_ref_iterator *fri = iter_arg;
  66         return iterator_seek(&fri->it, want);
  67 }
  68
  69 static int filtering_ref_iterator_next(void *iter_arg,
  70                                        struct reftable_record *rec)
  71 {
  72         struct filtering_ref_iterator *fri = iter_arg;
  73         struct reftable_ref_record *ref = &rec->u.ref;
  74         int err = 0;
  75         while (1) {
  76                 err = reftable_iterator_next_ref(&fri->it, ref);
  77                 if (err != 0) {
  78                         break;
  79                 }
  80
  81                 if (ref->value_type == REFTABLE_REF_VAL2 &&
  82                     (!memcmp(fri->oid.buf, ref->value.val2.target_value,
  83                              fri->oid.len) ||
  84                      !memcmp(fri->oid.buf, ref->value.val2.value,
  85                              fri->oid.len)))
  86                         return 0;
  87
  88                 if (ref->value_type == REFTABLE_REF_VAL1 &&
  89                     !memcmp(fri->oid.buf, ref->value.val1, fri->oid.len)) {
  90                         return 0;
  91                 }
  92         }
  93
  94         reftable_ref_record_release(ref);
  95         return err;
  96 }
  97
  98 static struct reftable_iterator_vtable filtering_ref_iterator_vtable = {
  99         .seek = &filtering_ref_iterator_seek,
 100         .next = &filtering_ref_iterator_next,
 101         .close = &filtering_ref_iterator_close,
 102 };
 103
 104 void iterator_from_filtering_ref_iterator(struct reftable_iterator *it,
 105                                           struct filtering_ref_iterator *fri)
 106 {
 107         assert(!it->ops);
 108         it->iter_arg = fri;
 109         it->ops = &filtering_ref_iterator_vtable;
 110 }
 111
 112 static void indexed_table_ref_iter_close(void *p)
 113 {
 114         struct indexed_table_ref_iter *it = p;
 115         block_iter_close(&it->cur);
 116         reftable_block_done(&it->block_reader.block);
 117         reftable_free(it->offsets);
 118         strbuf_release(&it->oid);
 119 }
 120
 121 static int indexed_table_ref_iter_next_block(struct indexed_table_ref_iter *it)
 122 {
 123         uint64_t off;
 124         int err = 0;
 125         if (it->offset_idx == it->offset_len) {
 126                 it->is_finished = 1;
 127                 return 1;
 128         }
 129
 130         reftable_block_done(&it->block_reader.block);
 131
 132         off = it->offsets[it->offset_idx++];
 133         err = reader_init_block_reader(it->r, &it->block_reader, off,
 134                                        BLOCK_TYPE_REF);
 135         if (err < 0) {
 136                 return err;
 137         }
 138         if (err > 0) {
 139                 /* indexed block does not exist. */
 140                 return REFTABLE_FORMAT_ERROR;
 141         }
 142         block_iter_seek_start(&it->cur, &it->block_reader);
 143         return 0;
 144 }
 145
 146 static int indexed_table_ref_iter_seek(void *p UNUSED,
 147                                        struct reftable_record *want UNUSED)
 148 {
 149         BUG("seeking indexed table is not supported");
 150         return -1;
 151 }
 152
 153 static int indexed_table_ref_iter_next(void *p, struct reftable_record *rec)
 154 {
 155         struct indexed_table_ref_iter *it = p;
 156         struct reftable_ref_record *ref = &rec->u.ref;
 157
 158         while (1) {
 159                 int err = block_iter_next(&it->cur, rec);
 160                 if (err < 0) {
 161                         return err;
 162                 }
 163
 164                 if (err > 0) {
 165                         err = indexed_table_ref_iter_next_block(it);
 166                         if (err < 0) {
 167                                 return err;
 168                         }
 169
 170                         if (it->is_finished) {
 171                                 return 1;
 172                         }
 173                         continue;
 174                 }
 175                 /* BUG */
 176                 if (!memcmp(it->oid.buf, ref->value.val2.target_value,
 177                             it->oid.len) ||
 178                     !memcmp(it->oid.buf, ref->value.val2.value, it->oid.len)) {
 179                         return 0;
 180                 }
 181         }
 182 }
 183
 184 int new_indexed_table_ref_iter(struct indexed_table_ref_iter **dest,
 185                                struct reftable_reader *r, uint8_t *oid,
 186                                int oid_len, uint64_t *offsets, int offset_len)
 187 {
 188         struct indexed_table_ref_iter empty = INDEXED_TABLE_REF_ITER_INIT;
 189         struct indexed_table_ref_iter *itr = reftable_calloc(1, sizeof(*itr));
 190         int err = 0;
 191
 192         *itr = empty;
 193         itr->r = r;
 194         strbuf_add(&itr->oid, oid, oid_len);
 195
 196         itr->offsets = offsets;
 197         itr->offset_len = offset_len;
 198
 199         err = indexed_table_ref_iter_next_block(itr);
 200         if (err < 0) {
 201                 reftable_free(itr);
 202         } else {
 203                 *dest = itr;
 204         }
 205         return err;
 206 }
 207
 208 static struct reftable_iterator_vtable indexed_table_ref_iter_vtable = {
 209         .seek = &indexed_table_ref_iter_seek,
 210         .next = &indexed_table_ref_iter_next,
 211         .close = &indexed_table_ref_iter_close,
 212 };
 213
 214 void iterator_from_indexed_table_ref_iter(struct reftable_iterator *it,
 215                                           struct indexed_table_ref_iter *itr)
 216 {
 217         assert(!it->ops);
 218         it->iter_arg = itr;
 219         it->ops = &indexed_table_ref_iter_vtable;
 220 }
 221
 222 void reftable_iterator_destroy(struct reftable_iterator *it)
 223 {
 224         if (!it->ops)
 225                 return;
 226         it->ops->close(it->iter_arg);
 227         it->ops = NULL;
 228         FREE_AND_NULL(it->iter_arg);
 229 }
 230
 231 int reftable_iterator_seek_ref(struct reftable_iterator *it,
 232                                const char *name)
 233 {
 234         struct reftable_record want = {
 235                 .type = BLOCK_TYPE_REF,
 236                 .u.ref = {
 237                         .refname = (char *)name,
 238                 },
 239         };
 240         return it->ops->seek(it->iter_arg, &want);
 241 }
 242
 243 int reftable_iterator_next_ref(struct reftable_iterator *it,
 244                                struct reftable_ref_record *ref)
 245 {
 246         struct reftable_record rec = {
 247                 .type = BLOCK_TYPE_REF,
 248                 .u = {
 249                         .ref = *ref
 250                 },
 251         };
 252         int err = iterator_next(it, &rec);
 253         *ref = rec.u.ref;
 254         return err;
 255 }
 256
 257 int reftable_iterator_seek_log_at(struct reftable_iterator *it,
 258                                   const char *name, uint64_t update_index)
 259 {
 260         struct reftable_record want = {
 261                 .type = BLOCK_TYPE_LOG,
 262                 .u.log = {
 263                         .refname = (char *)name,
 264                         .update_index = update_index,
 265                 },
 266         };
 267         return it->ops->seek(it->iter_arg, &want);
 268 }
 269
 270 int reftable_iterator_seek_log(struct reftable_iterator *it,
 271                                const char *name)
 272 {
 273         return reftable_iterator_seek_log_at(it, name, ~((uint64_t) 0));
 274 }
 275
 276 int reftable_iterator_next_log(struct reftable_iterator *it,
 277                                struct reftable_log_record *log)
 278 {
 279         struct reftable_record rec = {
 280                 .type = BLOCK_TYPE_LOG,
 281                 .u = {
 282                         .log = *log,
 283                 },
 284         };
 285         int err = iterator_next(it, &rec);
 286         *log = rec.u.log;
 287         return err;
 288 }