Squashed 'libbitcoinkernel-sys/bitcoin/' changes from 9e203b460d8a..73acb3ff8a04

73acb3ff8a04 kernel: Add pure kernel bitcoin-chainstate
6c26da3dc494 kernel: Add functions to get the block hash from a block
99d302a824f5 kernel: Add block index utility functions to C header
7d1583ec269f kernel: Add function to read block undo data from disk to C header
7af127e174e8 kernel: Add functions to read block from disk to C header
700087ca1112 kernel: Add function for copying  block data to C header
db9b5fa92db4 kernel: Add functions for the block validation state to C header
ae178c846341 kernel: Add validation interface to C header
f5ecbabe94d9 kernel: Add interrupt function to C header
08a52f02bf84 kernel: Add import blocks function to C header
3ced859f0f9f kernel: Add chainstate load options for in-memory dbs in C header
b3a1f0c65ec0 kernel: Add options for reindexing in C header
bde14cb16090 kernel: Add block validation to C header
3ebee13826d3 Kernel: Add chainstate loading to kernel C header
593999ab9a6c kernel: Add chainstate manager option for setting worker threads
78dda8e7474f kernel: Add chainstate manager object to C header
436db528893b kernel: Add notifications context option to C header
2e4e30d45c39 kerenl: Add chain params context option to C header
20f1d3996ec6 kernel: Add kernel library context object
f3ab2302a1c3 kernel: Add logging to kernel library C header
REVERT: 9e203b460d8a kernel: Add pure kernel bitcoin-chainstate
REVERT: a568bf9a494d kernel: Add functions to get the block hash from a block
REVERT: 237b97dd542b kernel: Add block index utility functions to C header
REVERT: f6b3f264e2f6 kernel: Add function to read block undo data from disk to C header
REVERT: 90875aedcd64 kernel: Add functions to read block from disk to C header
REVERT: 90b9adb287b6 kernel: Add function for copying  block data to C header
REVERT: d17e5dd695f4 kernel: Add functions for the block validation state to C header
REVERT: f61407f19aaf kernel: Add validation interface to C header
REVERT: 6d2b74ee03fe kernel: Add interrupt function to C header
REVERT: 1385c03b10c5 kernel: Add import blocks function to C header
REVERT: 229d696f3826 kernel: Add chainstate load options for in-memory dbs in C header
REVERT: d239f5504ca2 kernel: Add options for reindexing in C header
REVERT: d351759979f4 kernel: Add block validation to C header
REVERT: 4ebfbf84491f Kernel: Add chainstate loading to kernel C header
REVERT: b15df6bb21f1 kernel: Add chainstate manager option for setting worker threads
REVERT: e2cbb3265c44 kernel: Add chainstate manager object to C header
REVERT: 2818646db5f8 kernel: Add notifications context option to C header
REVERT: eb91f6c35dd5 kerenl: Add chain params context option to C header
REVERT: a1045172f381 kernel: Add kernel library context object
REVERT: 373f260d97ec kernel: Add logging to kernel library C header

git-subtree-dir: libbitcoinkernel-sys/bitcoin
git-subtree-split: 73acb3ff8a04cddc4904c446c2521dd2b2abc84d

Author: TheCharlatan

src/kernel/bitcoin-chainstate.cpp

@@ -4,6 +4,8 @@
 #include <filesystem>
 #include <iostream>
 #include <optional>
+#include <string>
+#include <string_view>
 #include <sstream>
 
 std::vector<unsigned char> hex_string_to_char_vec(const std::string& hex)
@@ -22,7 +24,7 @@ std::vector<unsigned char> hex_string_to_char_vec(const std::string& hex)
 class KernelLog
 {
 public:
-    void LogMessage(const char* message)
+    void LogMessage(std::string_view message)
     {
         std::cout << "kernel: " << message;
     }
@@ -96,12 +98,12 @@ class TestKernelNotifications : public KernelNotifications<TestKernelNotificatio
         std::cout << "Block tip changed" << std::endl;
     }
 
-    void ProgressHandler(const char* title, int progress_percent, bool resume_possible) override
+    void ProgressHandler(std::string_view title, int progress_percent, bool resume_possible) override
     {
         std::cout << "Made progress: " << title << " " << progress_percent << "%" << std::endl;
     }
 
-    void WarningSetHandler(kernel_Warning warning, const char* message) override
+    void WarningSetHandler(kernel_Warning warning, std::string_view message) override
     {
         std::cout << message << std::endl;
     }
@@ -111,12 +113,12 @@ class TestKernelNotifications : public KernelNotifications<TestKernelNotificatio
         std::cout << "Warning unset: " << warning << std::endl;
     }
 
-    void FlushErrorHandler(const char* error) override
+    void FlushErrorHandler(std::string_view error) override
     {
         std::cout << error << std::endl;
     }
 
-    void FatalErrorHandler(const char* error) override
+    void FatalErrorHandler(std::string_view error) override
     {
         std::cout << error << std::endl;
     }

src/kernel/bitcoinkernel.cpp

@@ -174,21 +174,25 @@ class KernelNotifications : public kernel::Notifications
     {
         if (m_cbs.header_tip) m_cbs.header_tip((void*) m_cbs.user_data, cast_state(state), height, timestamp, presync);
     }
+    void progress(const bilingual_str& title, int progress_percent, bool resume_possible) override
+    {
+        if (m_cbs.progress) m_cbs.progress((void*) m_cbs.user_data, title.original.c_str(), title.original.length(), progress_percent, resume_possible);
+    }
     void warningSet(kernel::Warning id, const bilingual_str& message) override
     {
-        if (m_cbs.warning_set) m_cbs.warning_set((void*) m_cbs.user_data, cast_kernel_warning(id), message.original.c_str());
+        if (m_cbs.warning_set) m_cbs.warning_set((void*) m_cbs.user_data, cast_kernel_warning(id), message.original.c_str(), message.original.length());
     }
     void warningUnset(kernel::Warning id) override
     {
         if (m_cbs.warning_unset) m_cbs.warning_unset((void*) m_cbs.user_data, cast_kernel_warning(id));
     }
     void flushError(const bilingual_str& message) override
     {
-        if (m_cbs.flush_error) m_cbs.flush_error((void*) m_cbs.user_data, message.original.c_str());
+        if (m_cbs.flush_error) m_cbs.flush_error((void*) m_cbs.user_data, message.original.c_str(), message.original.length());
     }
     void fatalError(const bilingual_str& message) override
     {
-        if (m_cbs.fatal_error) m_cbs.fatal_error((void*) m_cbs.user_data, message.original.c_str());
+        if (m_cbs.fatal_error) m_cbs.fatal_error((void*) m_cbs.user_data, message.original.c_str(), message.original.length());
     }
 };
 
@@ -533,22 +537,22 @@ kernel_LoggingConnection* kernel_logging_connection_create(kernel_LogCallback ca
     LogInstance().m_log_sourcelocations = options.log_sourcelocations;
     LogInstance().m_always_print_category_level = options.always_print_category_levels;
 
-    auto connection{LogInstance().PushBackCallback([callback, user_data](const std::string& str) { callback((void*) user_data, str.c_str()); })};
+    auto connection{LogInstance().PushBackCallback([callback, user_data](const std::string& str) { callback((void*) user_data, str.c_str(), str.length()); })};
 
     try {
         // Only start logging if we just added the connection.
         if (LogInstance().NumConnections() == 1 && !LogInstance().StartLogging()) {
-            LogError("Logger start failed.\n");
+            LogError("Logger start failed.");
             LogInstance().DeleteCallback(connection);
             return nullptr;
         }
     } catch (std::exception& e) {
-        LogError("Logger start failed.\n");
+        LogError("Logger start failed.");
         LogInstance().DeleteCallback(connection);
         return nullptr;
     }
 
-    LogDebug(BCLog::KERNEL, "Logger connected.\n");
+    LogDebug(BCLog::KERNEL, "Logger connected.");
 
     auto heap_connection{new std::list<std::function<void(const std::string&)>>::iterator(connection)};
     return reinterpret_cast<kernel_LoggingConnection*>(heap_connection);
@@ -561,7 +565,7 @@ void kernel_logging_connection_destroy(kernel_LoggingConnection* connection_)
         return;
     }
 
-    LogDebug(BCLog::KERNEL, "Logger disconnected.\n");
+    LogDebug(BCLog::KERNEL, "Logger disconnected.");
     LogInstance().DeleteCallback(*connection);
     delete connection;
 
@@ -641,7 +645,7 @@ kernel_Context* kernel_context_create(const kernel_ContextOptions* options_)
     bool sane{true};
     auto context{new Context{options, sane}};
     if (!sane) {
-        LogError("Kernel context sanity check failed.\n");
+        LogError("Kernel context sanity check failed.");
         delete context;
         return nullptr;
     }
@@ -697,10 +701,10 @@ kernel_BlockValidationResult kernel_get_block_validation_result_from_block_valid
     assert(false);
 }
 
-kernel_ChainstateManagerOptions* kernel_chainstate_manager_options_create(const kernel_Context* context_, const char* data_dir)
+kernel_ChainstateManagerOptions* kernel_chainstate_manager_options_create(const kernel_Context* context_, const char* data_dir, size_t data_dir_len)
 {
     try {
-        fs::path abs_data_dir{fs::absolute(fs::PathFromString(data_dir))};
+        fs::path abs_data_dir{fs::absolute(fs::PathFromString({data_dir, data_dir_len}))};
         fs::create_directories(abs_data_dir);
         auto context{cast_const_context(context_)};
         return reinterpret_cast<kernel_ChainstateManagerOptions*>(new ChainstateManager::Options{
@@ -709,7 +713,7 @@ kernel_ChainstateManagerOptions* kernel_chainstate_manager_options_create(const
             .notifications = *context->m_notifications,
             .signals = context->m_signals.get()});
     } catch (const std::exception& e) {
-        LogError("Failed to create chainstate manager options: %s\n", e.what());
+        LogError("Failed to create chainstate manager options: %s", e.what());
         return nullptr;
     }
 }
@@ -727,10 +731,10 @@ void kernel_chainstate_manager_options_destroy(kernel_ChainstateManagerOptions*
     }
 }
 
-kernel_BlockManagerOptions* kernel_block_manager_options_create(const kernel_Context* context_, const char* blocks_dir)
+kernel_BlockManagerOptions* kernel_block_manager_options_create(const kernel_Context* context_, const char* blocks_dir, size_t blocks_dir_len)
 {
     try {
-        fs::path abs_blocks_dir{fs::absolute(fs::PathFromString(blocks_dir))};
+        fs::path abs_blocks_dir{fs::absolute(fs::PathFromString({blocks_dir, blocks_dir_len}))};
         fs::create_directories(abs_blocks_dir);
         auto context{cast_const_context(context_)};
         if (!context) {
@@ -741,7 +745,7 @@ kernel_BlockManagerOptions* kernel_block_manager_options_create(const kernel_Con
             .blocks_dir = abs_blocks_dir,
             .notifications = *context->m_notifications});
     } catch (const std::exception& e) {
-        LogError("Failed to create block manager options; %s\n", e.what());
+        LogError("Failed to create block manager options; %s", e.what());
         return nullptr;
     }
 }
@@ -765,7 +769,7 @@ kernel_ChainstateManager* kernel_chainstate_manager_create(
     try {
         return reinterpret_cast<kernel_ChainstateManager*>(new ChainstateManager{*context->m_interrupt, *chainman_opts, *blockman_opts});
     } catch (const std::exception& e) {
-        LogError("Failed to create chainstate manager: %s\n", e.what());
+        LogError("Failed to create chainstate manager: %s", e.what());
         return nullptr;
     }
 }
@@ -824,7 +828,7 @@ bool kernel_chainstate_manager_load_chainstate(const kernel_Context* context_,
         auto& chainman{*cast_chainstate_manager(chainman_)};
 
         if (chainstate_load_opts.wipe_block_tree_db && !chainstate_load_opts.wipe_chainstate_db) {
-            LogError("Wiping the block tree db without also wiping the chainstate db is currently unsupported.\n");
+            LogWarning("Wiping the block tree db without also wiping the chainstate db is currently unsupported.");
             return false;
         }
 
@@ -834,24 +838,24 @@ bool kernel_chainstate_manager_load_chainstate(const kernel_Context* context_,
         cache_sizes.coins = (450 << 20) - (2 << 20) - (2 << 22);
         auto [status, chainstate_err]{node::LoadChainstate(chainman, cache_sizes, chainstate_load_opts)};
         if (status != node::ChainstateLoadStatus::SUCCESS) {
-            LogError("Failed to load chain state from your data directory: %s\n", chainstate_err.original);
+            LogError("Failed to load chain state from your data directory: %s", chainstate_err.original);
             return false;
         }
         std::tie(status, chainstate_err) = node::VerifyLoadedChainstate(chainman, chainstate_load_opts);
         if (status != node::ChainstateLoadStatus::SUCCESS) {
-            LogError("Failed to verify loaded chain state from your datadir: %s\n", chainstate_err.original);
+            LogError("Failed to verify loaded chain state from your datadir: %s", chainstate_err.original);
             return false;
         }
 
         for (Chainstate* chainstate : WITH_LOCK(::cs_main, return chainman.GetAll())) {
             BlockValidationState state;
             if (!chainstate->ActivateBestChain(state, nullptr)) {
-                LogError("Failed to connect best block: %s\n", state.ToString());
+                LogError("Failed to connect best block: %s", state.ToString());
                 return false;
             }
         }
     } catch (const std::exception& e) {
-        LogError("Failed to load chainstate: %s\n", e.what());
+        LogError("Failed to load chainstate: %s", e.what());
         return false;
     }
     return true;
@@ -880,6 +884,7 @@ void kernel_chainstate_manager_destroy(kernel_ChainstateManager* chainman_, cons
 bool kernel_import_blocks(const kernel_Context* context_,
                           kernel_ChainstateManager* chainman_,
                           const char** block_file_paths,
+                          size_t* block_file_paths_lens,
                           size_t block_file_paths_len)
 {
     try {
@@ -888,13 +893,13 @@ bool kernel_import_blocks(const kernel_Context* context_,
         import_files.reserve(block_file_paths_len);
         for (uint32_t i = 0; i < block_file_paths_len; i++) {
             if (block_file_paths[i] != nullptr) {
-                import_files.emplace_back(block_file_paths[i]);
+                import_files.emplace_back(std::string{block_file_paths[i], block_file_paths_lens[i]}.c_str());
             }
         }
         node::ImportBlocks(*chainman, import_files);
         chainman->ActiveChainstate().ForceFlushStateToDisk();
     } catch (const std::exception& e) {
-        LogError("Failed to import blocks: %s\n", e.what());
+        LogError("Failed to import blocks: %s", e.what());
         return false;
     }
     return true;
@@ -910,7 +915,7 @@ kernel_Block* kernel_block_create(const unsigned char* raw_block, size_t raw_blo
         stream >> TX_WITH_WITNESS(*block);
     } catch (const std::exception& e) {
         delete block;
-        LogDebug(BCLog::KERNEL, "Block decode failed.\n");
+        LogDebug(BCLog::KERNEL, "Block decode failed.");
         return nullptr;
     }
 
@@ -1001,7 +1006,7 @@ kernel_BlockIndex* kernel_get_block_index_from_hash(const kernel_Context* contex
     auto hash = uint256{Span<const unsigned char>{(*block_hash).hash, 32}};
     auto block_index = WITH_LOCK(::cs_main, return chainman->m_blockman.LookupBlockIndex(hash));
     if (!block_index) {
-        LogDebug(BCLog::KERNEL, "A block with the given hash is not indexed.\n");
+        LogDebug(BCLog::KERNEL, "A block with the given hash is not indexed.");
         return nullptr;
     }
     return reinterpret_cast<kernel_BlockIndex*>(block_index);
@@ -1014,7 +1019,7 @@ kernel_BlockIndex* kernel_get_block_index_from_height(const kernel_Context* cont
     LOCK(cs_main);
 
     if (height < 0 || height > chainman->ActiveChain().Height()) {
-        LogDebug(BCLog::KERNEL, "Block height is out of range.\n");
+        LogDebug(BCLog::KERNEL, "Block height is out of range.");
         return nullptr;
     }
     return reinterpret_cast<kernel_BlockIndex*>(chainman->ActiveChain()[height]);
@@ -1028,7 +1033,7 @@ kernel_BlockIndex* kernel_get_next_block_index(const kernel_Context* context_, k
     auto next_block_index{WITH_LOCK(::cs_main, return chainman->ActiveChain().Next(block_index))};
 
     if (!next_block_index) {
-        LogTrace(BCLog::KERNEL, "The block index is the tip of the current chain, it does not have a next.\n");
+        LogTrace(BCLog::KERNEL, "The block index is the tip of the current chain, it does not have a next.");
     }
 
     return reinterpret_cast<kernel_BlockIndex*>(next_block_index);
@@ -1039,7 +1044,7 @@ kernel_BlockIndex* kernel_get_previous_block_index(const kernel_BlockIndex* bloc
     const CBlockIndex* block_index{cast_const_block_index(block_index_)};
 
     if (!block_index->pprev) {
-        LogTrace(BCLog::KERNEL, "The block index is the genesis, it has no previous.\n");
+        LogTrace(BCLog::KERNEL, "The block index is the genesis, it has no previous.");
         return nullptr;
     }
 
@@ -1055,7 +1060,7 @@ kernel_Block* kernel_read_block_from_disk(const kernel_Context* context_,
 
     auto block{new std::shared_ptr<CBlock>(new CBlock{})};
     if (!chainman->m_blockman.ReadBlockFromDisk(**block, *block_index)) {
-        LogError("Failed to read block from disk.\n");
+        LogError("Failed to read block from disk.");
         return nullptr;
     }
     return reinterpret_cast<kernel_Block*>(block);
@@ -1069,12 +1074,12 @@ kernel_BlockUndo* kernel_read_block_undo_from_disk(const kernel_Context* context
     const auto block_index{cast_const_block_index(block_index_)};
 
     if (block_index->nHeight < 1) {
-        LogError("The genesis block does not have undo data.\n");
+        LogDebug(BCLog::KERNEL, "The genesis block does not have undo data.");
         return nullptr;
     }
     auto block_undo{new CBlockUndo{}};
     if (!chainman->m_blockman.UndoReadFromDisk(*block_undo, *block_index)) {
-        LogError("Failed to read undo data from disk.\n");
+        LogError("Failed to read undo data from disk.");
         return nullptr;
     }
     return reinterpret_cast<kernel_BlockUndo*>(block_undo);
@@ -1112,14 +1117,14 @@ kernel_TransactionOutput* kernel_get_undo_output_by_index(const kernel_BlockUndo
     const auto block_undo{cast_const_block_undo(block_undo_)};
 
     if (transaction_undo_index >= block_undo->vtxundo.size()) {
-        LogInfo("transaction undo index is out of bounds.\n");
+        LogInfo("transaction undo index is out of bounds.");
         return nullptr;
     }
 
     const auto& tx_undo = block_undo->vtxundo[transaction_undo_index];
 
     if (output_index >= tx_undo.vprevout.size()) {
-        LogInfo("previous output index is out of bounds.\n");
+        LogInfo("previous output index is out of bounds.");
         return nullptr;
     }
 

src/kernel/bitcoinkernel.h

@@ -261,18 +261,18 @@ typedef enum {
  * Function signature for the global logging callback. All bitcoin kernel
  * internal logs will pass through this callback.
  */
-typedef void (*kernel_LogCallback)(void* user_data, const char* message);
+typedef void (*kernel_LogCallback)(void* user_data, const char* message, size_t message_len);
 
 /**
  * Function signatures for the kernel notifications.
  */
 typedef void (*kernel_NotifyBlockTip)(void* user_data, kernel_SynchronizationState state, const kernel_BlockIndex* index);
 typedef void (*kernel_NotifyHeaderTip)(void* user_data, kernel_SynchronizationState state, int64_t height, int64_t timestamp, bool presync);
-typedef void (*kernel_NotifyProgress)(void* user_data, const char* title, int progress_percent, bool resume_possible);
-typedef void (*kernel_NotifyWarningSet)(void* user_data, kernel_Warning warning, const char* message);
+typedef void (*kernel_NotifyProgress)(void* user_data, const char* title, size_t title_len, int progress_percent, bool resume_possible);
+typedef void (*kernel_NotifyWarningSet)(void* user_data, kernel_Warning warning, const char* message, size_t message_len);
 typedef void (*kernel_NotifyWarningUnset)(void* user_data, kernel_Warning warning);
-typedef void (*kernel_NotifyFlushError)(void* user_data, const char* message);
-typedef void (*kernel_NotifyFatalError)(void* user_data, const char* message);
+typedef void (*kernel_NotifyFlushError)(void* user_data, const char* message, size_t message_len);
+typedef void (*kernel_NotifyFatalError)(void* user_data, const char* message, size_t message_len);
 
 /**
  * Function signatures for the validation interface.
@@ -678,13 +678,14 @@ void kernel_context_destroy(kernel_Context* context);
  * @param[in] context        Non-null, the created options will associate with this kernel context
  *                           for the duration of their lifetime. The same context needs to be used
  *                           when instantiating the chainstate manager.
- * @param[in] data_directory Non-null, directory containing the chainstate data. If the directory
- *                           does not exist yet, it will be created.
+ * @param[in] data_directory Non-null, path string of the directory containing the chainstate data.
+ *                           If the directory does not exist yet, it will be created.
  * @return                   The allocated chainstate manager options, or null on error.
  */
 kernel_ChainstateManagerOptions* BITCOINKERNEL_WARN_UNUSED_RESULT kernel_chainstate_manager_options_create(
     const kernel_Context* context,
-    const char* data_directory
+    const char* data_directory,
+    size_t data_directory_len
 ) BITCOINKERNEL_ARG_NONNULL(1, 2);
 
 /**
@@ -699,13 +700,14 @@ void kernel_chainstate_manager_options_destroy(kernel_ChainstateManagerOptions*
  * @param[in] context          Non-null, the created options will associate with this kernel context
  *                             for the duration of their lifetime. The same context needs to be used
  *                             when instantiating the chainstate manager.
- * @param[in] blocks_directory Non-null, directory containing the block data. If the directory does
- *                             not exist yet, it will be created.
+ * @param[in] blocks_directory Non-null, path string of the directory containing the block data. If
+ *                             the directory does not exist yet, it will be created.
  * @return                     The allocated block manager options, or null on error.
  */
 kernel_BlockManagerOptions* BITCOINKERNEL_WARN_UNUSED_RESULT kernel_block_manager_options_create(
     const kernel_Context* context,
-    const char* blocks_directory
+    const char* blocks_directory,
+    size_t blocks_directory_len
 ) BITCOINKERNEL_ARG_NONNULL(1, 2);
 
 /**
@@ -832,7 +834,7 @@ bool BITCOINKERNEL_WARN_UNUSED_RESULT kernel_chainstate_manager_load_chainstate(
  */
 bool kernel_import_blocks(const kernel_Context* context,
                           kernel_ChainstateManager* chainstate_manager,
-                          const char** block_file_paths, size_t block_file_paths_len
+                          const char** block_file_paths, size_t* block_file_paths_lens, size_t block_file_paths_len
 ) BITCOINKERNEL_ARG_NONNULL(1, 2);
 
 /**