text: // Copyright (c) 2012-2018 The Bitcoin Core developers
  // Distributed under the MIT software license, see the accompanying
  // file COPYING or http://www.opensource.org/licenses/mit-license.php.
  
  #ifndef BITCOIN_DBWRAPPER_H
  #define BITCOIN_DBWRAPPER_H
  
  #include <clientversion.h>
  #include <fs.h>
  #include <serialize.h>
  #include <streams.h>
  #include <util/system.h>
  #include <util/strencodings.h>
  
  #include <leveldb/db.h>
  #include <leveldb/write_batch.h>
  
  static const size_t DBWRAPPER_PREALLOC_KEY_SIZE = 64;
  static const size_t DBWRAPPER_PREALLOC_VALUE_SIZE = 1024;
  
  class dbwrapper_error : public std::runtime_error
  {
  public:
      explicit dbwrapper_error(const std::string& msg) : std::runtime_error(msg) {}
  };
  
  class CDBWrapper;
  
  /** These should be considered an implementation detail of the specific database.
   */
  namespace dbwrapper_private {
  
  /** Handle database error by throwing dbwrapper_error exception.
   */
  void HandleError(const leveldb::Status& status);
  
  /** Work around circular dependency, as well as for testing in dbwrapper_tests.
   * Database obfuscation should be considered an implementation detail of the
   * specific database.
   */
  const std::vector<unsigned char>& GetObfuscateKey(const CDBWrapper &w);
  
  };
  
  /** Batch of changes queued to be written to a CDBWrapper */
  class CDBBatch
  {
      friend class CDBWrapper;
  
  private:
      const CDBWrapper &parent;
      leveldb::WriteBatch batch;
  
      CDataStream ssKey;
      CDataStream ssValue;
  
      size_t size_estimate;
  
  public:
      /**
       * @param[in] _parent   CDBWrapper that this batch is to be submitted to
       */
      explicit CDBBatch(const CDBWrapper &_parent) : parent(_parent), ssKey(SER_DISK, CLIENT_VERSION), ssValue(SER_DISK, CLIENT_VERSION), size_estimate(0) { };
  
      void Clear()
      {
          batch.Clear();
          size_estimate = 0;
      }
  
      template <typename K, typename V>
      void Write(const K& key, const V& value)
      {
          ssKey.reserve(DBWRAPPER_PREALLOC_KEY_SIZE);
          ssKey << key;
          leveldb::Slice slKey(ssKey.data(), ssKey.size());
  
          ssValue.reserve(DBWRAPPER_PREALLOC_VALUE_SIZE);
          ssValue << value;
          ssValue.Xor(dbwrapper_private::GetObfuscateKey(parent));
          leveldb::Slice slValue(ssValue.data(), ssValue.size());
  
          batch.Put(slKey, slValue);
          // LevelDB serializes writes as:
          // - byte: header
          // - varint: key length (1 byte up to 127B, 2 bytes up to 16383B, ...)
          // - byte[]: key
          // - varint: value length
          // - byte[]: value
          // The formula below assumes the key and value are both less than 16k.
          size_estimate += 3 + (slKey.size() > 127) + slKey.size() + (slValue.size() > 127) + slValue.size();
          ssKey.clear();
          ssValue.clear();
      }
  
      template <typename K>
      void Erase(const K& key)
      {
          ssKey.reserve(DBWRAPPER_PREALLOC_KEY_SIZE);
          ssKey << key;
          leveldb::Slice slKey(ssKey.data(), ssKey.size());
  
          batch.Delete(slKey);
          // LevelDB serializes erases as:
          // - byte: header
          // - varint: key length
          // - byte[]: key
          // The formula below assumes the key is less than 16kB.
          size_estimate += 2 + (slKey.size() > 127) + slKey.size();
          ssKey.clear();
      }
  
      size_t SizeEstimate() const { return size_estimate; }
  };
  
  class CDBIterator
  {
  private:
      const CDBWrapper &parent;
      leveldb::Iterator *piter;
  
  public:
  
      /**
       * @param[in] _parent          Parent CDBWrapper instance.
       * @param[in] _piter           The original leveldb iterator.
       */
      CDBIterator(const CDBWrapper &_parent, leveldb::Iterator *_piter) :
          parent(_parent), piter(_piter) { };
      ~CDBIterator();
  
      bool Valid() const;
  
      void SeekToFirst();
  
      template<typename K> void Seek(const K& key) {
          CDataStream ssKey(SER_DISK, CLIENT_VERSION);
          ssKey.reserve(DBWRAPPER_PREALLOC_KEY_SIZE);
          ssKey << key;
          leveldb::Slice slKey(ssKey.data(), ssKey.size());
          piter->Seek(slKey);
      }
  
      void Next();
  
      template<typename K> bool GetKey(K& key) {
          leveldb::Slice slKey = piter->key();
          try {
              CDataStream ssKey(slKey.data(), slKey.data() + slKey.size(), SER_DISK, CLIENT_VERSION);
              ssKey >> key;
          } catch (const std::exception&) {
              return false;
          }
          return true;
      }
  
      template<typename V> bool GetValue(V& value) {
          leveldb::Slice slValue = piter->value();
          try {
              CDataStream ssValue(slValue.data(), slValue.data() + slValue.size(), SER_DISK, CLIENT_VERSION);
              ssValue.Xor(dbwrapper_private::GetObfuscateKey(parent));
              ssValue >> value;
          } catch (const std::exception&) {
              return false;
          }
          return true;
      }
  
      unsigned int GetValueSize() {
          return piter->value().size();
      }
  
  };
  
  class CDBWrapper
  {
      friend const std::vector<unsigned char>& dbwrapper_private::GetObfuscateKey(const CDBWrapper &w);
  private:
      //! custom environment this database is using (may be nullptr in case of default environment)
      leveldb::Env* penv;
  
      //! database options used
      leveldb::Options options;
  
      //! options used when reading from the database
      leveldb::ReadOptions readoptions;
  
      //! options used when iterating over values of the database
      leveldb::ReadOptions iteroptions;
  
      //! options used when writing to the database
      leveldb::WriteOptions writeoptions;
  
      //! options used when sync writing to the database
      leveldb::WriteOptions syncoptions;
  
      //! the database itself
      leveldb::DB* pdb;
  
      //! the name of this database
      std::string m_name;
  
      //! a key used for optional XOR-obfuscation of the database
      std::vector<unsigned char> obfuscate_key;
  
      //! the key under which the obfuscation key is stored
      static const std::string OBFUSCATE_KEY_KEY;
  
      //! the length of the obfuscate key in number of bytes
      static const unsigned int OBFUSCATE_KEY_NUM_BYTES;
  
      std::vector<unsigned char> CreateObfuscateKey() const;
  
  public:
      /**
       * @param[in] path        Location in the filesystem where leveldb data will be stored.
       * @param[in] nCacheSize  Configures various leveldb cache settings.
       * @param[in] fMemory     If true, use leveldb's memory environment.
       * @param[in] fWipe       If true, remove all existing data.
       * @param[in] obfuscate   If true, store data obfuscated via simple XOR. If false, XOR
       *                        with a zero'd byte array.
       */
      CDBWrapper(const fs::path& path, size_t nCacheSize, bool fMemory = false, bool fWipe = false, bool obfuscate = false);
      ~CDBWrapper();
  
      CDBWrapper(const CDBWrapper&) = delete;
      CDBWrapper& operator=(const CDBWrapper&) = delete;
  
      template <typename K, typename V>
      bool Read(const K& key, V& value) const
      {
          CDataStream ssKey(SER_DISK, CLIENT_VERSION);
          ssKey.reserve(DBWRAPPER_PREALLOC_KEY_SIZE);
          ssKey << key;
          leveldb::Slice slKey(ssKey.data(), ssKey.size());
  
          std::string strValue;
          leveldb::Status status = pdb->Get(readoptions, slKey, &strValue);
          if (!status.ok()) {
              if (status.IsNotFound())
                  return false;
              LogPrintf("LevelDB read failure: %s\n", status.ToString());
              dbwrapper_private::HandleError(status);
          }
          try {
              CDataStream ssValue(strValue.data(), strValue.data() + strValue.size(), SER_DISK, CLIENT_VERSION);
              ssValue.Xor(obfuscate_key);
              ssValue >> value;
          } catch (const std::exception&) {
              return false;
          }
          return true;
      }
  
      template <typename K, typename V>
      bool Write(const K& key, const V& value, bool fSync = false)
      {
          CDBBatch batch(*this);
          batch.Write(key, value);
          return WriteBatch(batch, fSync);
      }
  
      template <typename K>
      bool Exists(const K& key) const
      {
          CDataStream ssKey(SER_DISK, CLIENT_VERSION);
          ssKey.reserve(DBWRAPPER_PREALLOC_KEY_SIZE);
          ssKey << key;
          leveldb::Slice slKey(ssKey.data(), ssKey.size());
  
          std::string strValue;
          leveldb::Status status = pdb->Get(readoptions, slKey, &strValue);
          if (!status.ok()) {
              if (status.IsNotFound())
                  return false;
              LogPrintf("LevelDB read failure: %s\n", status.ToString());
              dbwrapper_private::HandleError(status);
          }
          return true;
      }
  
      template <typename K>
      bool Erase(const K& key, bool fSync = false)
      {
          CDBBatch batch(*this);
          batch.Erase(key);
          return WriteBatch(batch, fSync);
      }
  
      bool WriteBatch(CDBBatch& batch, bool fSync = false);
  
      // Get an estimate of LevelDB memory usage (in bytes).
      size_t DynamicMemoryUsage() const;
  
      // not available for LevelDB; provide for compatibility with BDB
      bool Flush()
      {
          return true;
      }
  
      bool Sync()
      {
          CDBBatch batch(*this);
          return WriteBatch(batch, true);
      }
  
      CDBIterator *NewIterator()
      {
          return new CDBIterator(*this, pdb->NewIterator(iteroptions));
      }
  
      /**
       * Return true if the database managed by this class contains no entries.
       */
      bool IsEmpty();
  
      template<typename K>
      size_t EstimateSize(const K& key_begin, const K& key_end) const
      {
          CDataStream ssKey1(SER_DISK, CLIENT_VERSION), ssKey2(SER_DISK, CLIENT_VERSION);
          ssKey1.reserve(DBWRAPPER_PREALLOC_KEY_SIZE);
          ssKey2.reserve(DBWRAPPER_PREALLOC_KEY_SIZE);
          ssKey1 << key_begin;
          ssKey2 << key_end;
          leveldb::Slice slKey1(ssKey1.data(), ssKey1.size());
          leveldb::Slice slKey2(ssKey2.data(), ssKey2.size());
          uint64_t size = 0;
          leveldb::Range range(slKey1, slKey2);
          pdb->GetApproximateSizes(&range, 1, &size);
          return size;
      }
  
      /**
       * Compact a certain range of keys in the database.
       */
      template<typename K>
      void CompactRange(const K& key_begin, const K& key_end) const
      {
          CDataStream ssKey1(SER_DISK, CLIENT_VERSION), ssKey2(SER_DISK, CLIENT_VERSION);
          ssKey1.reserve(DBWRAPPER_PREALLOC_KEY_SIZE);
          ssKey2.reserve(DBWRAPPER_PREALLOC_KEY_SIZE);
          ssKey1 << key_begin;
          ssKey2 << key_end;
          leveldb::Slice slKey1(ssKey1.data(), ssKey1.size());
          leveldb::Slice slKey2(ssKey2.data(), ssKey2.size());
          pdb->CompactRange(&slKey1, &slKey2);
      }
  
  };
  
  #endif // BITCOIN_DBWRAPPER_H
  