src/dbwrapper.h

   1 // Copyright (c) 2012-2015 The Bitcoin Core developers
   2 // Distributed under the MIT software license, see the accompanying
   3 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
   4
   5 #ifndef BITCOIN_DBWRAPPER_H
   6 #define BITCOIN_DBWRAPPER_H
   7
   8 #include "clientversion.h"
   9 #include "serialize.h"
  10 #include "streams.h"
  11 #include "util.h"
  12 #include "utilstrencodings.h"
  13 #include "version.h"
  14
  15 #include <boost/filesystem/path.hpp>
  16
  17 #include <leveldb/db.h>
  18 #include <leveldb/write_batch.h>
  19
  20 static const size_t DBWRAPPER_PREALLOC_KEY_SIZE = 64;
  21 static const size_t DBWRAPPER_PREALLOC_VALUE_SIZE = 1024;
  22
  23 class dbwrapper_error : public std::runtime_error
  24 {
  25 public:
  26     dbwrapper_error(const std::string& msg) : std::runtime_error(msg) {}
  27 };
  28
  29 class CDBWrapper;
  30
  31 /** These should be considered an implementation detail of the specific database.
  32  */
  33 namespace dbwrapper_private {
  34
  35 /** Handle database error by throwing dbwrapper_error exception.
  36  */
  37 void HandleError(const leveldb::Status& status);
  38
  39 /** Work around circular dependency, as well as for testing in dbwrapper_tests.
  40  * Database obfuscation should be considered an implementation detail of the
  41  * specific database.
  42  */
  43 const std::vector<unsigned char>& GetObfuscateKey(const CDBWrapper &w);
  44
  45 };
  46
  47 /** Batch of changes queued to be written to a CDBWrapper */
  48 class CDBBatch
  49 {
  50     friend class CDBWrapper;
  51
  52 private:
  53     const CDBWrapper &parent;
  54     leveldb::WriteBatch batch;
  55
  56 public:
  57     /**
  58      * @param[in] _parent   CDBWrapper that this batch is to be submitted to
  59      */
  60     CDBBatch(const CDBWrapper &_parent) : parent(_parent) { };
  61
  62     template <typename K, typename V>
  63     void Write(const K& key, const V& value)
  64     {
  65         CDataStream ssKey(SER_DISK, CLIENT_VERSION);
  66         ssKey.reserve(DBWRAPPER_PREALLOC_KEY_SIZE);
  67         ssKey << key;
  68         leveldb::Slice slKey(&ssKey[0], ssKey.size());
  69
  70         CDataStream ssValue(SER_DISK, CLIENT_VERSION);
  71         ssValue.reserve(DBWRAPPER_PREALLOC_VALUE_SIZE);
  72         ssValue << value;
  73         ssValue.Xor(dbwrapper_private::GetObfuscateKey(parent));
  74         leveldb::Slice slValue(&ssValue[0], ssValue.size());
  75
  76         batch.Put(slKey, slValue);
  77     }
  78
  79     template <typename K>
  80     void Erase(const K& key)
  81     {
  82         CDataStream ssKey(SER_DISK, CLIENT_VERSION);
  83         ssKey.reserve(DBWRAPPER_PREALLOC_KEY_SIZE);
  84         ssKey << key;
  85         leveldb::Slice slKey(&ssKey[0], ssKey.size());
  86
  87         batch.Delete(slKey);
  88     }
  89 };
  90
  91 class CDBIterator
  92 {
  93 private:
  94     const CDBWrapper &parent;
  95     leveldb::Iterator *piter;
  96
  97 public:
  98
  99     /**
 100      * @param[in] _parent          Parent CDBWrapper instance.
 101      * @param[in] _piter           The original leveldb iterator.
 102      */
 103     CDBIterator(const CDBWrapper &_parent, leveldb::Iterator *_piter) :
 104         parent(_parent), piter(_piter) { };
 105     ~CDBIterator();
 106
 107     bool Valid();
 108
 109     void SeekToFirst();
 110
 111     template<typename K> void Seek(const K& key) {
 112         CDataStream ssKey(SER_DISK, CLIENT_VERSION);
 113         ssKey.reserve(DBWRAPPER_PREALLOC_KEY_SIZE);
 114         ssKey << key;
 115         leveldb::Slice slKey(&ssKey[0], ssKey.size());
 116         piter->Seek(slKey);
 117     }
 118
 119     void Next();
 120
 121     template<typename K> bool GetKey(K& key) {
 122         leveldb::Slice slKey = piter->key();
 123         try {
 124             CDataStream ssKey(slKey.data(), slKey.data() + slKey.size(), SER_DISK, CLIENT_VERSION);
 125             ssKey >> key;
 126         } catch (const std::exception&) {
 127             return false;
 128         }
 129         return true;
 130     }
 131
 132     unsigned int GetKeySize() {
 133         return piter->key().size();
 134     }
 135
 136     template<typename V> bool GetValue(V& value) {
 137         leveldb::Slice slValue = piter->value();
 138         try {
 139             CDataStream ssValue(slValue.data(), slValue.data() + slValue.size(), SER_DISK, CLIENT_VERSION);
 140             ssValue.Xor(dbwrapper_private::GetObfuscateKey(parent));
 141             ssValue >> value;
 142         } catch (const std::exception&) {
 143             return false;
 144         }
 145         return true;
 146     }
 147
 148     unsigned int GetValueSize() {
 149         return piter->value().size();
 150     }
 151
 152 };
 153
 154 class CDBWrapper
 155 {
 156     friend const std::vector<unsigned char>& dbwrapper_private::GetObfuscateKey(const CDBWrapper &w);
 157 private:
 158     //! custom environment this database is using (may be NULL in case of default environment)
 159     leveldb::Env* penv;
 160
 161     //! database options used
 162     leveldb::Options options;
 163
 164     //! options used when reading from the database
 165     leveldb::ReadOptions readoptions;
 166
 167     //! options used when iterating over values of the database
 168     leveldb::ReadOptions iteroptions;
 169
 170     //! options used when writing to the database
 171     leveldb::WriteOptions writeoptions;
 172
 173     //! options used when sync writing to the database
 174     leveldb::WriteOptions syncoptions;
 175
 176     //! the database itself
 177     leveldb::DB* pdb;
 178
 179     //! a key used for optional XOR-obfuscation of the database
 180     std::vector<unsigned char> obfuscate_key;
 181
 182     //! the key under which the obfuscation key is stored
 183     static const std::string OBFUSCATE_KEY_KEY;
 184
 185     //! the length of the obfuscate key in number of bytes
 186     static const unsigned int OBFUSCATE_KEY_NUM_BYTES;
 187
 188     std::vector<unsigned char> CreateObfuscateKey() const;
 189
 190 public:
 191     /**
 192      * @param[in] path        Location in the filesystem where leveldb data will be stored.
 193      * @param[in] nCacheSize  Configures various leveldb cache settings.
 194      * @param[in] fMemory     If true, use leveldb's memory environment.
 195      * @param[in] fWipe       If true, remove all existing data.
 196      * @param[in] obfuscate   If true, store data obfuscated via simple XOR. If false, XOR
 197      *                        with a zero'd byte array.
 198      */
 199     CDBWrapper(const boost::filesystem::path& path, size_t nCacheSize, bool fMemory = false, bool fWipe = false, bool obfuscate = false);
 200     ~CDBWrapper();
 201
 202     template <typename K, typename V>
 203     bool Read(const K& key, V& value) const
 204     {
 205         CDataStream ssKey(SER_DISK, CLIENT_VERSION);
 206         ssKey.reserve(DBWRAPPER_PREALLOC_KEY_SIZE);
 207         ssKey << key;
 208         leveldb::Slice slKey(&ssKey[0], ssKey.size());
 209
 210         std::string strValue;
 211         leveldb::Status status = pdb->Get(readoptions, slKey, &strValue);
 212         if (!status.ok()) {
 213             if (status.IsNotFound())
 214                 return false;
 215             LogPrintf("LevelDB read failure: %s\n", status.ToString());
 216             dbwrapper_private::HandleError(status);
 217         }
 218         try {
 219             CDataStream ssValue(strValue.data(), strValue.data() + strValue.size(), SER_DISK, CLIENT_VERSION);
 220             ssValue.Xor(obfuscate_key);
 221             ssValue >> value;
 222         } catch (const std::exception&) {
 223             return false;
 224         }
 225         return true;
 226     }
 227
 228     template <typename K, typename V>
 229     bool Write(const K& key, const V& value, bool fSync = false)
 230     {
 231         CDBBatch batch(*this);
 232         batch.Write(key, value);
 233         return WriteBatch(batch, fSync);
 234     }
 235
 236     template <typename K>
 237     bool Exists(const K& key) const
 238     {
 239         CDataStream ssKey(SER_DISK, CLIENT_VERSION);
 240         ssKey.reserve(DBWRAPPER_PREALLOC_KEY_SIZE);
 241         ssKey << key;
 242         leveldb::Slice slKey(&ssKey[0], ssKey.size());
 243
 244         std::string strValue;
 245         leveldb::Status status = pdb->Get(readoptions, slKey, &strValue);
 246         if (!status.ok()) {
 247             if (status.IsNotFound())
 248                 return false;
 249             LogPrintf("LevelDB read failure: %s\n", status.ToString());
 250             dbwrapper_private::HandleError(status);
 251         }
 252         return true;
 253     }
 254
 255     template <typename K>
 256     bool Erase(const K& key, bool fSync = false)
 257     {
 258         CDBBatch batch(*this);
 259         batch.Erase(key);
 260         return WriteBatch(batch, fSync);
 261     }
 262
 263     bool WriteBatch(CDBBatch& batch, bool fSync = false);
 264
 265     // not available for LevelDB; provide for compatibility with BDB
 266     bool Flush()
 267     {
 268         return true;
 269     }
 270
 271     bool Sync()
 272     {
 273         CDBBatch batch(*this);
 274         return WriteBatch(batch, true);
 275     }
 276
 277     CDBIterator *NewIterator()
 278     {
 279         return new CDBIterator(*this, pdb->NewIterator(iteroptions));
 280     }
 281
 282     /**
 283      * Return true if the database managed by this class contains no entries.
 284      */
 285     bool IsEmpty();
 286 };
 287
 288 #endif // BITCOIN_DBWRAPPER_H
 289