chunk-format.c

   1 #define USE_THE_REPOSITORY_VARIABLE
   2
   3 #include "git-compat-util.h"
   4 #include "chunk-format.h"
   5 #include "csum-file.h"
   6 #include "gettext.h"
   7 #include "hash.h"
   8 #include "trace2.h"
   9
  10 /*
  11  * When writing a chunk-based file format, collect the chunks in
  12  * an array of chunk_info structs. The size stores the _expected_
  13  * amount of data that will be written by write_fn.
  14  */
  15 struct chunk_info {
  16         uint32_t id;
  17         uint64_t size;
  18         chunk_write_fn write_fn;
  19
  20         const void *start;
  21 };
  22
  23 struct chunkfile {
  24         struct hashfile *f;
  25
  26         struct chunk_info *chunks;
  27         size_t chunks_nr;
  28         size_t chunks_alloc;
  29 };
  30
  31 struct chunkfile *init_chunkfile(struct hashfile *f)
  32 {
  33         struct chunkfile *cf = xcalloc(1, sizeof(*cf));
  34         cf->f = f;
  35         return cf;
  36 }
  37
  38 void free_chunkfile(struct chunkfile *cf)
  39 {
  40         if (!cf)
  41                 return;
  42         free(cf->chunks);
  43         free(cf);
  44 }
  45
  46 int get_num_chunks(struct chunkfile *cf)
  47 {
  48         return cf->chunks_nr;
  49 }
  50
  51 void add_chunk(struct chunkfile *cf,
  52                uint32_t id,
  53                size_t size,
  54                chunk_write_fn fn)
  55 {
  56         ALLOC_GROW(cf->chunks, cf->chunks_nr + 1, cf->chunks_alloc);
  57
  58         cf->chunks[cf->chunks_nr].id = id;
  59         cf->chunks[cf->chunks_nr].write_fn = fn;
  60         cf->chunks[cf->chunks_nr].size = size;
  61         cf->chunks_nr++;
  62 }
  63
  64 int write_chunkfile(struct chunkfile *cf, void *data)
  65 {
  66         int i, result = 0;
  67         uint64_t cur_offset = hashfile_total(cf->f);
  68
  69         trace2_region_enter("chunkfile", "write", the_repository);
  70
  71         /* Add the table of contents to the current offset */
  72         cur_offset += (cf->chunks_nr + 1) * CHUNK_TOC_ENTRY_SIZE;
  73
  74         for (i = 0; i < cf->chunks_nr; i++) {
  75                 hashwrite_be32(cf->f, cf->chunks[i].id);
  76                 hashwrite_be64(cf->f, cur_offset);
  77
  78                 cur_offset += cf->chunks[i].size;
  79         }
  80
  81         /* Trailing entry marks the end of the chunks */
  82         hashwrite_be32(cf->f, 0);
  83         hashwrite_be64(cf->f, cur_offset);
  84
  85         for (i = 0; i < cf->chunks_nr; i++) {
  86                 off_t start_offset = hashfile_total(cf->f);
  87                 result = cf->chunks[i].write_fn(cf->f, data);
  88
  89                 if (result)
  90                         goto cleanup;
  91
  92                 if (hashfile_total(cf->f) - start_offset != cf->chunks[i].size)
  93                         BUG("expected to write %"PRId64" bytes to chunk %"PRIx32", but wrote %"PRId64" instead",
  94                             cf->chunks[i].size, cf->chunks[i].id,
  95                             hashfile_total(cf->f) - start_offset);
  96         }
  97
  98 cleanup:
  99         trace2_region_leave("chunkfile", "write", the_repository);
 100         return result;
 101 }
 102
 103 int read_table_of_contents(struct chunkfile *cf,
 104                            const unsigned char *mfile,
 105                            size_t mfile_size,
 106                            uint64_t toc_offset,
 107                            int toc_length,
 108                            unsigned expected_alignment)
 109 {
 110         int i;
 111         uint32_t chunk_id;
 112         const unsigned char *table_of_contents = mfile + toc_offset;
 113
 114         ALLOC_GROW(cf->chunks, toc_length, cf->chunks_alloc);
 115
 116         while (toc_length--) {
 117                 uint64_t chunk_offset, next_chunk_offset;
 118
 119                 chunk_id = get_be32(table_of_contents);
 120                 chunk_offset = get_be64(table_of_contents + 4);
 121
 122                 if (!chunk_id) {
 123                         error(_("terminating chunk id appears earlier than expected"));
 124                         return 1;
 125                 }
 126                 if (chunk_offset % expected_alignment != 0) {
 127                         error(_("chunk id %"PRIx32" not %d-byte aligned"),
 128                               chunk_id, expected_alignment);
 129                         return 1;
 130                 }
 131
 132                 table_of_contents += CHUNK_TOC_ENTRY_SIZE;
 133                 next_chunk_offset = get_be64(table_of_contents + 4);
 134
 135                 if (next_chunk_offset < chunk_offset ||
 136                     next_chunk_offset > mfile_size - the_hash_algo->rawsz) {
 137                         error(_("improper chunk offset(s) %"PRIx64" and %"PRIx64""),
 138                               chunk_offset, next_chunk_offset);
 139                         return -1;
 140                 }
 141
 142                 for (i = 0; i < cf->chunks_nr; i++) {
 143                         if (cf->chunks[i].id == chunk_id) {
 144                                 error(_("duplicate chunk ID %"PRIx32" found"),
 145                                         chunk_id);
 146                                 return -1;
 147                         }
 148                 }
 149
 150                 cf->chunks[cf->chunks_nr].id = chunk_id;
 151                 cf->chunks[cf->chunks_nr].start = mfile + chunk_offset;
 152                 cf->chunks[cf->chunks_nr].size = next_chunk_offset - chunk_offset;
 153                 cf->chunks_nr++;
 154         }
 155
 156         chunk_id = get_be32(table_of_contents);
 157         if (chunk_id) {
 158                 error(_("final chunk has non-zero id %"PRIx32""), chunk_id);
 159                 return -1;
 160         }
 161
 162         return 0;
 163 }
 164
 165 struct pair_chunk_data {
 166         const unsigned char **p;
 167         size_t *size;
 168 };
 169
 170 static int pair_chunk_fn(const unsigned char *chunk_start,
 171                          size_t chunk_size,
 172                          void *data)
 173 {
 174         struct pair_chunk_data *pcd = data;
 175         *pcd->p = chunk_start;
 176         *pcd->size = chunk_size;
 177         return 0;
 178 }
 179
 180 int pair_chunk(struct chunkfile *cf,
 181                uint32_t chunk_id,
 182                const unsigned char **p,
 183                size_t *size)
 184 {
 185         struct pair_chunk_data pcd = { .p = p, .size = size };
 186         return read_chunk(cf, chunk_id, pair_chunk_fn, &pcd);
 187 }
 188
 189 int read_chunk(struct chunkfile *cf,
 190                uint32_t chunk_id,
 191                chunk_read_fn fn,
 192                void *data)
 193 {
 194         int i;
 195
 196         for (i = 0; i < cf->chunks_nr; i++) {
 197                 if (cf->chunks[i].id == chunk_id)
 198                         return fn(cf->chunks[i].start, cf->chunks[i].size, data);
 199         }
 200
 201         return CHUNK_NOT_FOUND;
 202 }
 203
 204 uint8_t oid_version(const struct git_hash_algo *algop)
 205 {
 206         switch (hash_algo_by_ptr(algop)) {
 207         case GIT_HASH_SHA1:
 208                 return 1;
 209         case GIT_HASH_SHA256:
 210                 return 2;
 211         default:
 212                 die(_("invalid hash version"));
 213         }
 214 }