#include "rustduck-sys/native/bridge/memory_handler.h"
#include "rustduck-sys/native/bridge/test_hooks.h"
#include "rustduck-sys/native/tspy.h"
#include "rustduck-sys/src/bridge.rs.h"
#include <cstdint>
#include <memory>
#include <stdexcept>
#include <type_traits>
namespace {
bool memory_callback(std::uint32_t event_code, const tspy_uchar *plugin_name,
std::size_t plugin_name_size, std::size_t, std::size_t,
std::size_t, std::size_t, std::size_t,
const std::uint8_t *data, std::size_t data_size,
std::size_t data_max_size, bool data_read_only,
void *event_data) noexcept {
try {
const bool plugin_name_valid =
plugin_name != nullptr || plugin_name_size == 0;
const bool data_valid = data != nullptr || data_size == 0;
const auto *plugin_name_bytes =
reinterpret_cast<const std::uint8_t *>(plugin_name);
const rust::Slice<const std::uint8_t> plugin_name_slice(
plugin_name_bytes, plugin_name_valid ? plugin_name_size : 0);
const rust::Slice<const std::uint8_t> data_slice(
data, data_valid ? data_size : 0);
const auto validity = static_cast<std::uint8_t>(
(plugin_name_valid ? 0x01 : 0) | (data_valid ? 0x02 : 0) |
(event_data != nullptr ? 0x04 : 0));
auto result =
rustduck_memory_callback(event_code, plugin_name_slice, data_slice,
data_max_size, data_read_only, validity);
if (!result.ok) {
return false;
}
if (!data_read_only) {
if (event_data == nullptr || result.data.size() > data_max_size) {
rustduck_memory_callback_writeback_failure(event_code);
return false;
}
rustduck_test_maybe_fail(RustDuckFailurePoint::MemoryWriteback);
std::uint8_t empty = 0;
void *writeback_data = result.data.empty()
? static_cast<void *>(&empty)
: static_cast<void *>(result.data.data());
tspyPyPluginEventHandlerUpdateData(event_data, writeback_data,
result.data.size());
}
return true;
} catch (...) {
rustduck_memory_callback_writeback_failure(event_code);
return false;
}
}
static_assert(
std::is_convertible_v<decltype(&memory_callback), tspy_plugin_callback>);
}
RustDuckMemoryHandler::RustDuckMemoryHandler()
: handler_(tspyNewPyPluginEventHandler(memory_callback), [](void *pointer) {
if (pointer != nullptr) {
tspyDeletePyPluginEventHandler(pointer);
}
}) {
if (!handler_) {
throw std::runtime_error("native memory handler construction failed");
}
}
RustDuckMemoryHandler::~RustDuckMemoryHandler() noexcept = default;
void *RustDuckMemoryHandler::raw() const noexcept { return handler_.get(); }
std::shared_ptr<void> RustDuckMemoryHandler::retain() const noexcept {
return handler_;
}
std::unique_ptr<RustDuckMemoryHandler> rustduck_memory_handler_new() {
return std::make_unique<RustDuckMemoryHandler>();
}