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         reftable_buf_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         reftable_buf_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 indexed_table_ref_iter_new(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;
 190         int err = 0;
 191
 192         itr = reftable_calloc(1, sizeof(*itr));
 193         if (!itr) {
 194                 err = REFTABLE_OUT_OF_MEMORY_ERROR;
 195                 goto out;
 196         }
 197
 198         *itr = empty;
 199         itr->r = r;
 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;
 207
 208         err = indexed_table_ref_iter_next_block(itr);
 209         if (err < 0)
 210                 goto out;
 211
 212         *dest = itr;
 213         err = 0;
 214
 215 out:
 216         if (err < 0) {
 217                 *dest = NULL;
 218                 reftable_free(itr);
 219         }
 220         return err;
 221 }
 222
 223 static struct reftable_iterator_vtable indexed_table_ref_iter_vtable = {
 224         .seek = &indexed_table_ref_iter_seek,
 225         .next = &indexed_table_ref_iter_next,
 226         .close = &indexed_table_ref_iter_close,
 227 };
 228
 229 void iterator_from_indexed_table_ref_iter(struct reftable_iterator *it,
 230                                           struct indexed_table_ref_iter *itr)
 231 {
 232         assert(!it->ops);
 233         it->iter_arg = itr;
 234         it->ops = &indexed_table_ref_iter_vtable;
 235 }
 236
 237 void reftable_iterator_destroy(struct reftable_iterator *it)
 238 {
 239         if (!it->ops)
 240                 return;
 241         it->ops->close(it->iter_arg);
 242         it->ops = NULL;
 243         REFTABLE_FREE_AND_NULL(it->iter_arg);
 244 }
 245
 246 int reftable_iterator_seek_ref(struct reftable_iterator *it,
 247                                const char *name)
 248 {
 249         struct reftable_record want = {
 250                 .type = BLOCK_TYPE_REF,
 251                 .u.ref = {
 252                         .refname = (char *)name,
 253                 },
 254         };
 255         return it->ops->seek(it->iter_arg, &want);
 256 }
 257
 258 int reftable_iterator_next_ref(struct reftable_iterator *it,
 259                                struct reftable_ref_record *ref)
 260 {
 261         struct reftable_record rec = {
 262                 .type = BLOCK_TYPE_REF,
 263                 .u = {
 264                         .ref = *ref
 265                 },
 266         };
 267         int err = iterator_next(it, &rec);
 268         *ref = rec.u.ref;
 269         return err;
 270 }
 271
 272 int reftable_iterator_seek_log_at(struct reftable_iterator *it,
 273                                   const char *name, uint64_t update_index)
 274 {
 275         struct reftable_record want = {
 276                 .type = BLOCK_TYPE_LOG,
 277                 .u.log = {
 278                         .refname = (char *)name,
 279                         .update_index = update_index,
 280                 },
 281         };
 282         return it->ops->seek(it->iter_arg, &want);
 283 }
 284
 285 int reftable_iterator_seek_log(struct reftable_iterator *it,
 286                                const char *name)
 287 {
 288         return reftable_iterator_seek_log_at(it, name, ~((uint64_t) 0));
 289 }
 290
 291 int reftable_iterator_next_log(struct reftable_iterator *it,
 292                                struct reftable_log_record *log)
 293 {
 294         struct reftable_record rec = {
 295                 .type = BLOCK_TYPE_LOG,
 296                 .u = {
 297                         .log = *log,
 298                 },
 299         };
 300         int err = iterator_next(it, &rec);
 301         *log = rec.u.log;
 302         return err;
 303 }