Branch data Line data Source code
1 : : // Copyright (c) 2009-2010 Satoshi Nakamoto
2 : : // Copyright (c) 2009-present The Bitcoin Core developers
3 : : // Distributed under the MIT software license, see the accompanying
4 : : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
5 : :
6 : : #ifndef BITCOIN_WALLET_DB_H
7 : : #define BITCOIN_WALLET_DB_H
8 : :
9 : : #include <clientversion.h>
10 : : #include <streams.h>
11 : : #include <support/allocators/secure.h>
12 : : #include <util/fs.h>
13 : :
14 : : #include <atomic>
15 : : #include <memory>
16 : : #include <optional>
17 : : #include <string>
18 : :
19 : : class ArgsManager;
20 : : struct bilingual_str;
21 : :
22 : : namespace wallet {
23 : : // BytePrefix compares equality with other byte spans that begin with the same prefix.
24 : : struct BytePrefix {
25 : : std::span<const std::byte> prefix;
26 : : };
27 : : bool operator<(BytePrefix a, std::span<const std::byte> b);
28 : : bool operator<(std::span<const std::byte> a, BytePrefix b);
29 : :
30 : : class DatabaseCursor
31 : : {
32 : : public:
33 [ + - ]: 26781 : explicit DatabaseCursor() = default;
34 : 26781 : virtual ~DatabaseCursor() = default;
35 : :
36 : : DatabaseCursor(const DatabaseCursor&) = delete;
37 : : DatabaseCursor& operator=(const DatabaseCursor&) = delete;
38 : :
39 : : enum class Status
40 : : {
41 : : FAIL,
42 : : MORE,
43 : : DONE,
44 : : };
45 : :
46 : 0 : virtual Status Next(DataStream& key, DataStream& value) { return Status::FAIL; }
47 : : };
48 : :
49 : : /** RAII class that provides access to a WalletDatabase */
50 : : class DatabaseBatch
51 : : {
52 : : private:
53 : : virtual bool ReadKey(DataStream&& key, DataStream& value) = 0;
54 : : virtual bool WriteKey(DataStream&& key, DataStream&& value, bool overwrite = true) = 0;
55 : : virtual bool EraseKey(DataStream&& key) = 0;
56 : : virtual bool HasKey(DataStream&& key) = 0;
57 : :
58 : : public:
59 [ + - ]: 152030 : explicit DatabaseBatch() = default;
60 : 152030 : virtual ~DatabaseBatch() = default;
61 : :
62 : : DatabaseBatch(const DatabaseBatch&) = delete;
63 : : DatabaseBatch& operator=(const DatabaseBatch&) = delete;
64 : :
65 : : virtual void Close() = 0;
66 : :
67 : : template <typename K, typename T>
68 : 5832 : bool Read(const K& key, T& value)
69 : : {
70 [ + - ]: 5832 : DataStream ssKey{};
71 [ + - ]: 5832 : ssKey.reserve(1000);
72 : 5832 : ssKey << key;
73 : :
74 : 5832 : DataStream ssValue{};
75 [ + - + + ]: 5832 : if (!ReadKey(std::move(ssKey), ssValue)) return false;
76 : : try {
77 : 4142 : ssValue >> value;
78 : 974 : return true;
79 [ - - ]: 0 : } catch (const std::exception&) {
80 : : return false;
81 : : }
82 : 5832 : }
83 : :
84 : : template <typename K, typename T>
85 : 227153 : bool Write(const K& key, const T& value, bool fOverwrite = true)
86 : : {
87 [ + - ]: 227153 : DataStream ssKey{};
88 [ + - ]: 227153 : ssKey.reserve(1000);
89 : 227153 : ssKey << key;
90 : :
91 [ + - ]: 227153 : DataStream ssValue{};
92 [ + - ]: 227153 : ssValue.reserve(10000);
93 : 227153 : ssValue << value;
94 : :
95 [ + - ]: 227153 : return WriteKey(std::move(ssKey), std::move(ssValue), fOverwrite);
96 : 227153 : }
97 : :
98 : : template <typename K>
99 : 393 : bool Erase(const K& key)
100 : : {
101 [ + - ]: 393 : DataStream ssKey{};
102 [ + - ]: 393 : ssKey.reserve(1000);
103 : 393 : ssKey << key;
104 : :
105 [ + - ]: 393 : return EraseKey(std::move(ssKey));
106 : 393 : }
107 : :
108 : : template <typename K>
109 : 11 : bool Exists(const K& key)
110 : : {
111 [ + - ]: 11 : DataStream ssKey{};
112 [ + - ]: 11 : ssKey.reserve(1000);
113 : 11 : ssKey << key;
114 : :
115 [ + - ]: 11 : return HasKey(std::move(ssKey));
116 : 11 : }
117 : : virtual bool ErasePrefix(std::span<const std::byte> prefix) = 0;
118 : :
119 : : virtual std::unique_ptr<DatabaseCursor> GetNewCursor() = 0;
120 : : virtual std::unique_ptr<DatabaseCursor> GetNewPrefixCursor(std::span<const std::byte> prefix) = 0;
121 : : virtual bool TxnBegin() = 0;
122 : : virtual bool TxnCommit() = 0;
123 : : virtual bool TxnAbort() = 0;
124 : : virtual bool HasActiveTxn() = 0;
125 : : };
126 : :
127 : : /** An instance of this class represents one database.
128 : : **/
129 : : class WalletDatabase
130 : : {
131 : : public:
132 : : /** Create dummy DB handle */
133 [ + - ]: 1067 : WalletDatabase() = default;
134 : 1067 : virtual ~WalletDatabase() = default;
135 : :
136 : : /** Open the database if it is not already opened. */
137 : : virtual void Open() = 0;
138 : :
139 : : //! Counts the number of active database users to be sure that the database is not closed while someone is using it
140 : : std::atomic<int> m_refcount{0};
141 : :
142 : : /** Rewrite the entire database on disk, with the exception of key pszSkip if non-zero
143 : : */
144 : : virtual bool Rewrite(const char* pszSkip=nullptr) = 0;
145 : :
146 : : /** Back up the entire database to a file.
147 : : */
148 : : virtual bool Backup(const std::string& strDest) const = 0;
149 : :
150 : : /** Flush to the database file and close the database.
151 : : * Also close the environment if no other databases are open in it.
152 : : */
153 : : virtual void Close() = 0;
154 : :
155 : : /** Return path to main database file for logs and error messages. */
156 : : virtual std::string Filename() = 0;
157 : :
158 : : virtual std::string Format() = 0;
159 : :
160 : : /** Make a DatabaseBatch connected to this database */
161 : : virtual std::unique_ptr<DatabaseBatch> MakeBatch() = 0;
162 : : };
163 : :
164 : : enum class DatabaseFormat {
165 : : SQLITE,
166 : : BERKELEY_RO,
167 : : };
168 : :
169 [ + - + - : 2554 : struct DatabaseOptions {
+ - + + +
- ][ + - +
- + - # #
# # ]
[ + - # # ]
[ + - + - ]
170 : : bool require_existing = false;
171 : : bool require_create = false;
172 : : std::optional<DatabaseFormat> require_format;
173 : : uint64_t create_flags = 0;
174 : : SecureString create_passphrase;
175 : :
176 : : // Specialized options. Not every option is supported by every backend.
177 : : bool verify = true; //!< Check data integrity on load.
178 : : bool use_unsafe_sync = false; //!< Disable file sync for faster performance.
179 : : bool use_shared_memory = false; //!< Let other processes access the database.
180 : : int64_t max_log_mb = 100; //!< Max log size to allow before consolidating.
181 : : };
182 : :
183 : : enum class DatabaseStatus {
184 : : SUCCESS,
185 : : FAILED_BAD_PATH,
186 : : FAILED_BAD_FORMAT,
187 : : FAILED_ALREADY_LOADED,
188 : : FAILED_ALREADY_EXISTS,
189 : : FAILED_NOT_FOUND,
190 : : FAILED_CREATE,
191 : : FAILED_LOAD,
192 : : FAILED_VERIFY,
193 : : FAILED_ENCRYPT,
194 : : FAILED_INVALID_BACKUP_FILE,
195 : : };
196 : :
197 : : /** Recursively list database paths in directory. */
198 : : std::vector<std::pair<fs::path, std::string>> ListDatabases(const fs::path& path);
199 : :
200 : : void ReadDatabaseArgs(const ArgsManager& args, DatabaseOptions& options);
201 : : std::unique_ptr<WalletDatabase> MakeDatabase(const fs::path& path, const DatabaseOptions& options, DatabaseStatus& status, bilingual_str& error);
202 : :
203 : : fs::path BDBDataFile(const fs::path& path);
204 : : fs::path SQLiteDataFile(const fs::path& path);
205 : : bool IsBDBFile(const fs::path& path);
206 : : bool IsSQLiteFile(const fs::path& path);
207 : : } // namespace wallet
208 : :
209 : : #endif // BITCOIN_WALLET_DB_H
|
