reftable/blocksource.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 "system.h"
  10
  11 #include "basics.h"
  12 #include "blocksource.h"
  13 #include "reftable-blocksource.h"
  14 #include "reftable-error.h"
  15
  16 static void strbuf_return_block(void *b UNUSED, struct reftable_block *dest)
  17 {
  18         if (dest->len)
  19                 memset(dest->data, 0xff, dest->len);
  20         reftable_free(dest->data);
  21 }
  22
  23 static void strbuf_close(void *b UNUSED)
  24 {
  25 }
  26
  27 static int strbuf_read_block(void *v, struct reftable_block *dest, uint64_t off,
  28                              uint32_t size)
  29 {
  30         struct strbuf *b = v;
  31         assert(off + size <= b->len);
  32         REFTABLE_CALLOC_ARRAY(dest->data, size);
  33         if (!dest->data)
  34                 return -1;
  35         memcpy(dest->data, b->buf + off, size);
  36         dest->len = size;
  37         return size;
  38 }
  39
  40 static uint64_t strbuf_size(void *b)
  41 {
  42         return ((struct strbuf *)b)->len;
  43 }
  44
  45 static struct reftable_block_source_vtable strbuf_vtable = {
  46         .size = &strbuf_size,
  47         .read_block = &strbuf_read_block,
  48         .return_block = &strbuf_return_block,
  49         .close = &strbuf_close,
  50 };
  51
  52 void block_source_from_strbuf(struct reftable_block_source *bs,
  53                               struct strbuf *buf)
  54 {
  55         assert(!bs->ops);
  56         bs->ops = &strbuf_vtable;
  57         bs->arg = buf;
  58 }
  59
  60 struct file_block_source {
  61         uint64_t size;
  62         unsigned char *data;
  63 };
  64
  65 static uint64_t file_size(void *b)
  66 {
  67         return ((struct file_block_source *)b)->size;
  68 }
  69
  70 static void file_return_block(void *b UNUSED, struct reftable_block *dest UNUSED)
  71 {
  72 }
  73
  74 static void file_close(void *v)
  75 {
  76         struct file_block_source *b = v;
  77         munmap(b->data, b->size);
  78         reftable_free(b);
  79 }
  80
  81 static int file_read_block(void *v, struct reftable_block *dest, uint64_t off,
  82                            uint32_t size)
  83 {
  84         struct file_block_source *b = v;
  85         assert(off + size <= b->size);
  86         dest->data = b->data + off;
  87         dest->len = size;
  88         return size;
  89 }
  90
  91 static struct reftable_block_source_vtable file_vtable = {
  92         .size = &file_size,
  93         .read_block = &file_read_block,
  94         .return_block = &file_return_block,
  95         .close = &file_close,
  96 };
  97
  98 int reftable_block_source_from_file(struct reftable_block_source *bs,
  99                                     const char *name)
 100 {
 101         struct file_block_source *p;
 102         struct stat st;
 103         int fd, err;
 104
 105         fd = open(name, O_RDONLY);
 106         if (fd < 0) {
 107                 if (errno == ENOENT)
 108                         return REFTABLE_NOT_EXIST_ERROR;
 109                 err = -1;
 110                 goto out;
 111         }
 112
 113         if (fstat(fd, &st) < 0) {
 114                 err = REFTABLE_IO_ERROR;
 115                 goto out;
 116         }
 117
 118         REFTABLE_CALLOC_ARRAY(p, 1);
 119         if (!p) {
 120                 err = REFTABLE_OUT_OF_MEMORY_ERROR;
 121                 goto out;
 122         }
 123
 124         p->size = st.st_size;
 125         p->data = xmmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
 126
 127         assert(!bs->ops);
 128         bs->ops = &file_vtable;
 129         bs->arg = p;
 130
 131         err = 0;
 132
 133 out:
 134         if (fd >= 0)
 135                 close(fd);
 136         if (err < 0)
 137                 reftable_free(p);
 138         return 0;
 139 }