Inside Bitcoin

1// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file. See the AUTHORS file for names of contributors.
4
5#include "leveldb/c.h"
6
7#include <cstdint>
8#include <cstdlib>
9
10#include "leveldb/cache.h"
11#include "leveldb/comparator.h"
12#include "leveldb/db.h"
13#include "leveldb/env.h"
14#include "leveldb/filter_policy.h"
15#include "leveldb/iterator.h"
16#include "leveldb/options.h"
17#include "leveldb/status.h"
18#include "leveldb/write_batch.h"
19
20using leveldb::Cache;
21using leveldb::Comparator;
22using leveldb::CompressionType;
23using leveldb::DB;
24using leveldb::Env;
25using leveldb::FileLock;
26using leveldb::FilterPolicy;
27using leveldb::Iterator;
28using leveldb::kMajorVersion;
29using leveldb::kMinorVersion;
30using leveldb::Logger;
31using leveldb::NewBloomFilterPolicy;
32using leveldb::NewLRUCache;
33using leveldb::Options;
34using leveldb::RandomAccessFile;
35using leveldb::Range;
36using leveldb::ReadOptions;
37using leveldb::SequentialFile;
38using leveldb::Slice;
39using leveldb::Snapshot;
40using leveldb::Status;
41using leveldb::WritableFile;
42using leveldb::WriteBatch;
43using leveldb::WriteOptions;
44
45extern "C" {
46
47struct leveldb_t {
48  DB* rep;
49};
50struct leveldb_iterator_t {
51  Iterator* rep;
52};
53struct leveldb_writebatch_t {
54  WriteBatch rep;
55};
56struct leveldb_snapshot_t {
57  const Snapshot* rep;
58};
59struct leveldb_readoptions_t {
60  ReadOptions rep;
61};
62struct leveldb_writeoptions_t {
63  WriteOptions rep;
64};
65struct leveldb_options_t {
66  Options rep;
67};
68struct leveldb_cache_t {
69  Cache* rep;
70};
71struct leveldb_seqfile_t {
72  SequentialFile* rep;
73};
74struct leveldb_randomfile_t {
75  RandomAccessFile* rep;
76};
77struct leveldb_writablefile_t {
78  WritableFile* rep;
79};
80struct leveldb_logger_t {
81  Logger* rep;
82};
83struct leveldb_filelock_t {
84  FileLock* rep;
85};
86
87struct leveldb_comparator_t : public Comparator {
88  ~leveldb_comparator_t() override { (*destructor_)(state_); }
89
90  int Compare(const Slice& a, const Slice& b) const override {
91    return (*compare_)(state_, a.data(), a.size(), b.data(), b.size());
92  }
93
94  const char* Name() const override { return (*name_)(state_); }
95
96  // No-ops since the C binding does not support key shortening methods.
97  void FindShortestSeparator(std::string*, const Slice&) const override {}
98  void FindShortSuccessor(std::string* key) const override {}
99
100  void* state_;
101  void (*destructor_)(void*);
102  int (*compare_)(void*, const char* a, size_t alen, const char* b,
103                  size_t blen);
104  const char* (*name_)(void*);
105};
106
107struct leveldb_filterpolicy_t : public FilterPolicy {
108  ~leveldb_filterpolicy_t() override { (*destructor_)(state_); }
109
110  const char* Name() const override { return (*name_)(state_); }
111
112  void CreateFilter(const Slice* keys, int n, std::string* dst) const override {
113    std::vector<const char*> key_pointers(n);
114    std::vector<size_t> key_sizes(n);
115    for (int i = 0; i < n; i++) {
116      key_pointers[i] = keys[i].data();
117      key_sizes[i] = keys[i].size();
118    }
119    size_t len;
120    char* filter = (*create_)(state_, &key_pointers[0], &key_sizes[0], n, &len);
121    dst->append(filter, len);
122    free(filter);
123  }
124
125  bool KeyMayMatch(const Slice& key, const Slice& filter) const override {
126    return (*key_match_)(state_, key.data(), key.size(), filter.data(),
127                         filter.size());
128  }
129
130  void* state_;
131  void (*destructor_)(void*);
132  const char* (*name_)(void*);
133  char* (*create_)(void*, const char* const* key_array,
134                   const size_t* key_length_array, int num_keys,
135                   size_t* filter_length);
136  uint8_t (*key_match_)(void*, const char* key, size_t length,
137                        const char* filter, size_t filter_length);
138};
139
140struct leveldb_env_t {
141  Env* rep;
142  bool is_default;
143};
144
145static bool SaveError(char** errptr, const Status& s) {
146  assert(errptr != nullptr);
147  if (s.ok()) {
148    return false;
149  } else if (*errptr == nullptr) {
150    *errptr = strdup(s.ToString().c_str());
151  } else {
152    // TODO(sanjay): Merge with existing error?
153    free(*errptr);
154    *errptr = strdup(s.ToString().c_str());
155  }
156  return true;
157}
158
159static char* CopyString(const std::string& str) {
160  char* result = reinterpret_cast<char*>(malloc(sizeof(char) * str.size()));
161  memcpy(result, str.data(), sizeof(char) * str.size());
162  return result;
163}
164
165leveldb_t* leveldb_open(const leveldb_options_t* options, const char* name,
166                        char** errptr) {
167  DB* db;
168  if (SaveError(errptr, DB::Open(options->rep, std::string(name), &db))) {
169    return nullptr;
170  }
171  leveldb_t* result = new leveldb_t;
172  result->rep = db;
173  return result;
174}
175
176void leveldb_close(leveldb_t* db) {
177  delete db->rep;
178  delete db;
179}
180
181void leveldb_put(leveldb_t* db, const leveldb_writeoptions_t* options,
182                 const char* key, size_t keylen, const char* val, size_t vallen,
183                 char** errptr) {
184  SaveError(errptr,
185            db->rep->Put(options->rep, Slice(key, keylen), Slice(val, vallen)));
186}
187
188void leveldb_delete(leveldb_t* db, const leveldb_writeoptions_t* options,
189                    const char* key, size_t keylen, char** errptr) {
190  SaveError(errptr, db->rep->Delete(options->rep, Slice(key, keylen)));
191}
192
193void leveldb_write(leveldb_t* db, const leveldb_writeoptions_t* options,
194                   leveldb_writebatch_t* batch, char** errptr) {
195  SaveError(errptr, db->rep->Write(options->rep, &batch->rep));
196}
197
198char* leveldb_get(leveldb_t* db, const leveldb_readoptions_t* options,
199                  const char* key, size_t keylen, size_t* vallen,
200                  char** errptr) {
201  char* result = nullptr;
202  std::string tmp;
203  Status s = db->rep->Get(options->rep, Slice(key, keylen), &tmp);
204  if (s.ok()) {
205    *vallen = tmp.size();
206    result = CopyString(tmp);
207  } else {
208    *vallen = 0;
209    if (!s.IsNotFound()) {
210      SaveError(errptr, s);
211    }
212  }
213  return result;
214}
215
216leveldb_iterator_t* leveldb_create_iterator(
217    leveldb_t* db, const leveldb_readoptions_t* options) {
218  leveldb_iterator_t* result = new leveldb_iterator_t;
219  result->rep = db->rep->NewIterator(options->rep);
220  return result;
221}
222
223const leveldb_snapshot_t* leveldb_create_snapshot(leveldb_t* db) {
224  leveldb_snapshot_t* result = new leveldb_snapshot_t;
225  result->rep = db->rep->GetSnapshot();
226  return result;
227}
228
229void leveldb_release_snapshot(leveldb_t* db,
230                              const leveldb_snapshot_t* snapshot) {
231  db->rep->ReleaseSnapshot(snapshot->rep);
232  delete snapshot;
233}
234
235char* leveldb_property_value(leveldb_t* db, const char* propname) {
236  std::string tmp;
237  if (db->rep->GetProperty(Slice(propname), &tmp)) {
238    // We use strdup() since we expect human readable output.
239    return strdup(tmp.c_str());
240  } else {
241    return nullptr;
242  }
243}
244
245void leveldb_approximate_sizes(leveldb_t* db, int num_ranges,
246                               const char* const* range_start_key,
247                               const size_t* range_start_key_len,
248                               const char* const* range_limit_key,
249                               const size_t* range_limit_key_len,
250                               uint64_t* sizes) {