1
0
mirror of synced 2024-12-15 09:11:15 +01:00
ImHex/plugins/builtin/source/content/providers/gdb_provider.cpp

336 lines
10 KiB
C++
Raw Normal View History

#include "content/providers/gdb_provider.hpp"
#include <cstring>
#include <thread>
#include <chrono>
#include <imgui.h>
#include <hex/ui/imgui_imhex_extensions.h>
#include <hex/helpers/fmt.hpp>
#include <hex/helpers/crypto.hpp>
#include <hex/api/localization_manager.hpp>
#include <nlohmann/json.hpp>
namespace hex::plugin::builtin {
using namespace std::chrono_literals;
namespace gdb {
namespace {
u8 calculateChecksum(const std::string &data) {
u64 checksum = 0;
for (const auto &c : data)
checksum += c;
return checksum & 0xFF;
}
std::string createPacket(const std::string &data) {
return hex::format("${}#{:02x}", data, calculateChecksum(data));
}
std::optional<std::string> parsePacket(const std::string &packet) {
if (packet.length() < 4)
return std::nullopt;
if (!packet.starts_with('$'))
return std::nullopt;
if (packet[packet.length() - 3] != '#')
return std::nullopt;
2022-02-01 22:09:44 +01:00
std::string data = packet.substr(1, packet.length() - 4);
std::string checksum = packet.substr(packet.length() - 2, 2);
auto decodedChecksum = crypt::decode16(checksum);
if (checksum.length() != 2 || decodedChecksum.empty() || decodedChecksum[0] != calculateChecksum(data))
return std::nullopt;
return data;
}
}
2023-11-10 20:47:08 +01:00
void sendAck(const wolv::net::SocketClient &socket) {
socket.writeString("+");
}
2023-11-10 20:47:08 +01:00
void continueExecution(const wolv::net::SocketClient &socket) {
socket.writeString(createPacket("vCont;c"));
}
2023-11-10 20:47:08 +01:00
std::vector<u8> readMemory(const wolv::net::SocketClient &socket, u64 address, size_t size) {
std::string packet = createPacket(hex::format("m{:X},{:X}", address, size));
socket.writeString(packet);
auto receivedPacket = socket.readString(size * 2 + 4);
if (receivedPacket.empty())
return {};
auto receivedData = parsePacket(receivedPacket);
if (!receivedData.has_value())
return {};
if (receivedData->size() == 3 && receivedData->starts_with("E"))
return {};
auto data = crypt::decode16(receivedData.value());
data.resize(size);
return data;
}
2023-11-10 20:47:08 +01:00
void writeMemory(const wolv::net::SocketClient &socket, u64 address, const void *buffer, size_t size) {
std::vector<u8> bytes(size);
std::memcpy(bytes.data(), buffer, size);
std::string byteString = crypt::encode16(bytes);
std::string packet = createPacket(hex::format("M{:X},{:X}:{}", address, size, byteString));
socket.writeString(packet);
auto receivedPacket = socket.readString(6);
}
2023-11-10 20:47:08 +01:00
bool enableNoAckMode(const wolv::net::SocketClient &socket) {
socket.writeString(createPacket("QStartNoAckMode"));
auto ack = socket.readString(1);
if (ack.empty() || ack[0] != '+')
return false;
auto receivedPacket = socket.readString(6);
auto receivedData = parsePacket(receivedPacket);
if (receivedData && *receivedData == "OK") {
sendAck(socket);
return true;
} else {
return false;
}
}
}
2023-11-10 20:47:08 +01:00
GDBProvider::GDBProvider() : m_size(0xFFFF'FFFF) {
}
bool GDBProvider::isAvailable() const {
2023-12-19 13:10:25 +01:00
return m_socket.isConnected();
}
bool GDBProvider::isReadable() const {
2023-12-19 13:10:25 +01:00
return m_socket.isConnected();
}
bool GDBProvider::isWritable() const {
return true;
}
bool GDBProvider::isResizable() const {
return false;
}
bool GDBProvider::isSavable() const {
return false;
}
void GDBProvider::readRaw(u64 offset, void *buffer, size_t size) {
if ((offset - this->getBaseAddress()) > (this->getActualSize() - size) || buffer == nullptr || size == 0)
return;
offset -= this->getBaseAddress();
u64 alignedOffset = offset - (offset % CacheLineSize);
if (size <= CacheLineSize) {
2023-12-19 13:10:25 +01:00
std::scoped_lock lock(m_cacheLock);
2023-12-19 13:10:25 +01:00
const auto &cacheLine = std::find_if(m_cache.begin(), m_cache.end(), [&](auto &line) {
return line.address == alignedOffset;
});
2023-12-19 13:10:25 +01:00
if (cacheLine != m_cache.end()) {
// Cache hit
} else {
// Cache miss
2023-12-19 13:10:25 +01:00
m_cache.push_back({ alignedOffset, { 0 } });
}
2023-12-19 13:10:25 +01:00
if (cacheLine != m_cache.end())
2023-12-07 13:02:12 +01:00
std::memcpy(buffer, &cacheLine->data[0] + (offset % CacheLineSize), std::min<u64>(size, cacheLine->data.size()));
} else {
while (size > 0) {
2023-12-07 13:02:12 +01:00
size_t readSize = std::min<u64>(size, CacheLineSize);
2023-12-19 13:10:25 +01:00
auto data = gdb::readMemory(m_socket, offset, size);
if (!data.empty())
std::memcpy(buffer, &data[0], data.size());
size -= readSize;
offset += readSize;
}
}
}
void GDBProvider::writeRaw(u64 offset, const void *buffer, size_t size) {
if ((offset - this->getBaseAddress()) > (this->getActualSize() - size) || buffer == nullptr || size == 0)
return;
offset -= this->getBaseAddress();
2023-12-19 13:10:25 +01:00
gdb::writeMemory(m_socket, offset, buffer, size);
}
void GDBProvider::save() {
2023-04-06 17:36:28 +02:00
Provider::save();
}
u64 GDBProvider::getActualSize() const {
2023-12-19 13:10:25 +01:00
return m_size;
}
std::string GDBProvider::getName() const {
std::string address = "-";
std::string port = "-";
if (this->isConnected()) {
2023-12-19 13:10:25 +01:00
address = m_ipAddress;
port = std::to_string(m_port);
}
return hex::format("hex.builtin.provider.gdb.name"_lang, address, port);
}
std::vector<GDBProvider::Description> GDBProvider::getDataDescription() const {
return {
2023-12-19 13:10:25 +01:00
{"hex.builtin.provider.gdb.server"_lang, hex::format("{}:{}", m_ipAddress, m_port)},
};
}
bool GDBProvider::open() {
2023-12-19 13:10:25 +01:00
m_socket = wolv::net::SocketClient(wolv::net::SocketClient::Type::TCP);
m_socket.connect(m_ipAddress, m_port);
if (!gdb::enableNoAckMode(m_socket)) {
m_socket.disconnect();
return false;
}
2023-12-19 13:10:25 +01:00
if (m_socket.isConnected()) {
gdb::continueExecution(m_socket);
2023-12-19 13:10:25 +01:00
m_cacheUpdateThread = std::thread([this] {
auto cacheLine = m_cache.begin();
while (this->isConnected()) {
{
2023-12-19 13:10:25 +01:00
std::scoped_lock lock(m_cacheLock);
2023-12-19 13:10:25 +01:00
if (m_resetCache) {
m_cache.clear();
m_resetCache = false;
cacheLine = m_cache.begin();
}
2023-12-19 13:10:25 +01:00
if (cacheLine != m_cache.end()) {
std::vector<u8> data = gdb::readMemory(m_socket, cacheLine->address, CacheLineSize);
2023-12-19 13:10:25 +01:00
while (std::count_if(m_cache.begin(), m_cache.end(), [&](auto &line) { return !line.data.empty(); }) > 100) {
m_cache.pop_front();
cacheLine = m_cache.begin();
}
std::memcpy(cacheLine->data.data(), data.data(), data.size());
}
2023-12-19 13:10:25 +01:00
if (cacheLine == m_cache.end())
cacheLine = m_cache.begin();
else
2023-11-10 20:47:08 +01:00
++cacheLine;
}
std::this_thread::sleep_for(10ms);
}
});
return true;
} else {
return false;
}
}
void GDBProvider::close() {
2023-12-19 13:10:25 +01:00
m_socket.disconnect();
2023-12-19 13:10:25 +01:00
if (m_cacheUpdateThread.joinable()) {
m_cacheUpdateThread.join();
}
}
bool GDBProvider::isConnected() const {
2023-12-19 13:10:25 +01:00
return m_socket.isConnected();
}
bool GDBProvider::drawLoadInterface() {
2023-12-19 13:10:25 +01:00
ImGui::InputText("hex.builtin.provider.gdb.ip"_lang, m_ipAddress);
ImGui::InputInt("hex.builtin.provider.gdb.port"_lang, &m_port, 0, 0);
2022-01-20 23:24:26 +01:00
ImGui::Separator();
ImGuiExt::InputHexadecimal("hex.ui.common.size"_lang, &m_size, ImGuiInputTextFlags_CharsHexadecimal);
2022-01-20 23:24:26 +01:00
2023-12-19 13:10:25 +01:00
if (m_port < 0)
m_port = 0;
else if (m_port > 0xFFFF)
m_port = 0xFFFF;
2023-12-19 13:10:25 +01:00
return !m_ipAddress.empty() && m_port != 0;
}
void GDBProvider::loadSettings(const nlohmann::json &settings) {
Provider::loadSettings(settings);
2023-12-19 13:10:25 +01:00
m_ipAddress = settings.at("ip").get<std::string>();
m_port = settings.at("port").get<int>();
m_size = settings.at("size").get<size_t>();
}
nlohmann::json GDBProvider::storeSettings(nlohmann::json settings) const {
2023-12-19 13:10:25 +01:00
settings["ip"] = m_ipAddress;
settings["port"] = m_port;
settings["size"] = m_size;
return Provider::storeSettings(settings);
}
2022-08-14 14:45:18 +02:00
std::pair<Region, bool> GDBProvider::getRegionValidity(u64 address) const {
address -= this->getBaseAddress();
2022-08-14 14:45:18 +02:00
if (address < this->getActualSize())
return { Region { this->getBaseAddress() + address, this->getActualSize() - address }, true };
2022-08-14 14:45:18 +02:00
else
return { Region::Invalid(), false };
}
std::variant<std::string, i128> GDBProvider::queryInformation(const std::string &category, const std::string &argument) {
if (category == "ip")
2023-12-19 13:10:25 +01:00
return m_ipAddress;
else if (category == "port")
2023-12-19 13:10:25 +01:00
return m_port;
else
return Provider::queryInformation(category, argument);
}
}