1// Copyright (c) 2020-present 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#include <bitcoin-build-config.h> // IWYU pragma: keep
6
7#include <wallet/sqlite.h>
8
9#include <chainparams.h>
10#include <crypto/common.h>
11#include <sync.h>
12#include <util/check.h>
13#include <util/fs_helpers.h>
14#include <util/log.h>
15#include <util/strencodings.h>
16#include <util/translation.h>
17#include <wallet/db.h>
18
19#include <sqlite3.h>
20
21#include <cstdint>
22#include <optional>
23#include <utility>
24#include <vector>
25
26namespace wallet {
27static constexpr int32_t WALLET_SCHEMA_VERSION = 0;
28
29static std::span<const std::byte> SpanFromBlob(sqlite3_stmt* stmt, int col)
30{
31    return {reinterpret_cast<const std::byte*>(sqlite3_column_blob(stmt, col)),
32            static_cast<size_t>(sqlite3_column_bytes(stmt, col))};
33}
34
35static void ErrorLogCallback(void* arg, int code, const char* msg)
36{
37    // From sqlite3_config() documentation for the SQLITE_CONFIG_LOG option:
38    // "The void pointer that is the second argument to SQLITE_CONFIG_LOG is passed through as
39    // the first parameter to the application-defined logger function whenever that function is
40    // invoked."
41    // Assert that this is the case:
42    assert(arg == nullptr);
43    LogWarning("SQLite Error. Code: %d. Message: %s", code, msg);
44}
45
46static int TraceSqlCallback(unsigned code, void* context, void* param1, void* param2)
47{
48    auto* db = static_cast<SQLiteDatabase*>(context);
49    if (code == SQLITE_TRACE_STMT) {
50        auto* stmt = static_cast<sqlite3_stmt*>(param1);
51        // To be conservative and avoid leaking potentially secret information
52        // in the log file, only expand statements that query the database, not
53        // statements that update the database.
54        char* expanded{sqlite3_stmt_readonly(stmt) ? sqlite3_expanded_sql(stmt) : nullptr};
55        LogTrace(BCLog::WALLETDB, "[%s] SQLite Statement: %s\n", db->Filename(), expanded ? expanded : sqlite3_sql(stmt));
56        if (expanded) sqlite3_free(expanded);
57    }
58    return SQLITE_OK;
59}
60
61static bool BindBlobToStatement(sqlite3_stmt* stmt,
62                                int index,
63                                std::span<const std::byte> blob,
64                                const std::string& description)
65{
66    // Pass a pointer to the empty string "" below instead of passing the
67    // blob.data() pointer if the blob.data() pointer is null. Passing a null
68    // data pointer to bind_blob would cause sqlite to bind the SQL NULL value
69    // instead of the empty blob value X'', which would mess up SQL comparisons.
70    int res = sqlite3_bind_blob(stmt, index, blob.data() ? static_cast<const void*>(blob.data()) : "", blob.size(), SQLITE_STATIC);
71    if (res != SQLITE_OK) {
72        LogWarning("Unable to bind %s to statement: %s", description, sqlite3_errstr(res));
73        sqlite3_clear_bindings(stmt);
74        sqlite3_reset(stmt);
75        return false;
76    }
77
78    return true;
79}
80
81static std::optional<int> ReadPragmaInteger(sqlite3* db, const std::string& key, const std::string& description, bilingual_str& error)
82{
83    std::string stmt_text = strprintf("PRAGMA %s", key);
84    sqlite3_stmt* pragma_read_stmt{nullptr};
85    int ret = sqlite3_prepare_v2(db, stmt_text.c_str(), -1, &pragma_read_stmt, nullptr);
86    if (ret != SQLITE_OK) {
87        sqlite3_finalize(pragma_read_stmt);
88        error = Untranslated(strprintf("SQLiteDatabase: Failed to prepare the statement to fetch %s: %s", description, sqlite3_errstr(ret)));
89        return std::nullopt;
90    }
91    ret = sqlite3_step(pragma_read_stmt);
92    if (ret != SQLITE_ROW) {
93        sqlite3_finalize(pragma_read_stmt);
94        error = Untranslated(strprintf("SQLiteDatabase: Failed to fetch %s: %s", description, sqlite3_errstr(ret)));
95        return std::nullopt;
96    }
97    int result = sqlite3_column_int(pragma_read_stmt, 0);
98    sqlite3_finalize(pragma_read_stmt);
99    return result;
100}
101
102static void SetPragma(sqlite3* db, const std::string& key, const std::string& value, const std::string& err_msg)
103{
104    std::string stmt_text = strprintf("PRAGMA %s = %s", key, value);
105    int ret = sqlite3_exec(db, stmt_text.c_str(), nullptr, nullptr, nullptr);
106    if (ret != SQLITE_OK) {
107        throw std::runtime_error(strprintf("SQLiteDatabase: %s: %s\n", err_msg, sqlite3_errstr(ret)));
108    }
109}
110
111Mutex SQLiteDatabase::g_sqlite_mutex;
112int SQLiteDatabase::g_sqlite_count = 0;
113
114SQLiteDatabase::SQLiteDatabase(const fs::path& dir_path, const fs::path& file_path, const DatabaseOptions& options)
115    : SQLiteDatabase(dir_path, file_path, options, /*additional_flags=*/0)
116{}
117
118SQLiteDatabase::SQLiteDatabase(const fs::path& dir_path, const fs::path& file_path, const DatabaseOptions& options, int additional_flags)
119    : WalletDatabase(), m_dir_path(dir_path), m_file_path(fs::PathToString(file_path)), m_additional_flags(additional_flags), m_write_semaphore(1), m_use_unsafe_sync(options.use_unsafe_sync)
120{
121    {
122        LOCK(g_sqlite_mutex);
123        if (++g_sqlite_count == 1) {
124            // Setup logging
125            int ret = sqlite3_config(SQLITE_CONFIG_LOG, ErrorLogCallback, nullptr);
126            if (ret != SQLITE_OK) {
127                throw std::runtime_error(strprintf("SQLiteDatabase: Failed to setup error log: %s\n", sqlite3_errstr(ret)));
128            }
129            // Force serialized threading mode
130            ret = sqlite3_config(SQLITE_CONFIG_SERIALIZED);
131            if (ret != SQLITE_OK) {
132                throw std::runtime_error(strprintf("SQLiteDatabase: Failed to configure serialized threading mode: %s\n", sqlite3_errstr(ret)));
133            }
134        }
135        int ret = sqlite3_initialize(); // This is a no-op if sqlite3 is already initialized
136        if (ret != SQLITE_OK) {
137            throw std::runtime_error(strprintf("SQLiteDatabase: Failed to initialize SQLite: %s\n", sqlite3_errstr(ret)));
138        }
139    }
140
141    try {
142        Open(m_additional_flags);
143    } catch (const std::runtime_error&) {
144        // If open fails, cleanup this object and rethrow the exception
145        Cleanup();
146        throw;
147    }
148}
149
150void SQLiteBatch::SetupSQLStatements()
151{
152    const std::vector<std::pair<sqlite3_stmt**, const char*>> statements{
153        {&m_read_stmt, "SELECT value FROM main WHERE key = ?"},
154        {&m_insert_stmt, "INSERT INTO main VALUES(?, ?)"},
155        {&m_overwrite_stmt, "INSERT or REPLACE into main values(?, ?)"},
156        {&m_delete_stmt, "DELETE FROM main WHERE key = ?"},
157        {&m_delete_prefix_stmt, "DELETE FROM main WHERE instr(key, ?) = 1"},
158    };
159
160    for (const auto& [stmt_prepared, stmt_text] : statements) {
161        if (*stmt_prepared == nullptr) {
162            int res = sqlite3_prepare_v2(m_database.m_db, stmt_text, -1, stmt_prepared, nullptr);
163            if (res != SQLITE_OK) {
164                throw std::runtime_error(strprintf(
165                    "SQLiteDatabase: Failed to setup SQL statements: %s\n", sqlite3_errstr(res)));
166            }
167        }
168    }
169}
170
171SQLiteDatabase::~SQLiteDatabase()
172{
173    Cleanup();
174}
175
176void SQLiteDatabase::Cleanup() noexcept
177{
178    AssertLockNotHeld(g_sqlite_mutex);
179
180    Close();
181
182    LOCK(g_sqlite_mutex);
183    if (--g_sqlite_count == 0) {
184        int ret = sqlite3_shutdown();
185        if (ret != SQLITE_OK) {
186            LogWarning("SQLiteDatabase: Failed to shutdown SQLite: %s", sqlite3_errstr(ret));
187        }
188    }
189}
190
191bool SQLiteDatabase::Verify(bilingual_str& error)
192{
193    assert(m_db);
194
195    // Check the application ID matches our network magic
196    auto read_result = ReadPragmaInteger(m_db, "application_id", "the application id", error);
197    if (!read_result.has_value()) return false;
198    uint32_t app_id = static_cast<uint32_t>(read_result.value());
199    uint32_t net_magic = ReadBE32(Params().MessageStart().data());
200    if (app_id != net_magic) {
201        error = strprintf(_("SQLiteDatabase: Unexpected application id. Expected %u, got %u"), net_magic, app_id);
202        return false;
203    }
204
205    // Check our schema version
206    read_result = ReadPragmaInteger(m_db, "user_version", "sqlite wallet schema version", error);
207    if (!read_result.has_value()) return false;
208    int32_t user_ver = read_result.value();
209    if (user_ver != WALLET_SCHEMA_VERSION) {
210        error = strprintf(_("SQLiteDatabase: Unknown sqlite wallet schema version %d. Only version %d is supported"), user_ver, WALLET_SCHEMA_VERSION);
211        return false;
212    }
213
214    sqlite3_stmt* stmt{nullptr};
215    int ret = sqlite3_prepare_v2(m_db, "PRAGMA integrity_check", -1, &stmt, nullptr);
216    if (ret != SQLITE_OK) {
217        sqlite3_finalize(stmt);
218        error = strprintf(_("SQLiteDatabase: Failed to prepare statement to verify database: %s"), sqlite3_errstr(ret));
219        return false;
220    }
221    while (true) {
222        ret = sqlite3_step(stmt);
223        if (ret == SQLITE_DONE) {
224            break;
225        }
226        if (ret != SQLITE_ROW) {
227            error = strprintf(_("SQLiteDatabase: Failed to execute statement to verify database: %s"), sqlite3_errstr(ret));
228            break;
229        }
230        const char* msg = (const char*)sqlite3_column_text(stmt, 0);
231        if (!msg) {
232            error = strprintf(_("SQLiteDatabase: Failed to read database verification error: %s"), sqlite3_errstr(ret));
233            break;
234        }
235        std::string str_msg(msg);
236        if (str_msg == "ok") {
237            continue;
238        }
239        if (error.empty()) {
240            error = _("Failed to verify database") + Untranslated("\n");
241        }
242        error += Untranslated(strprintf("%s\n", str_msg));
243    }
244    sqlite3_finalize(stmt);
245    return error.empty();
246}
247
248void SQLiteDatabase::Open()
249{
250    if (m_additional_flags & SQLITE_OPEN_MEMORY) {