SendKey & SendSignal over rpc server

This commit is contained in:
Emanuele Curati 2024-08-19 20:41:30 +02:00 committed by OpenSauce
parent 43dbe42b29
commit baa93295b2
3 changed files with 53 additions and 8 deletions

View File

@ -15,6 +15,8 @@ enum class PacketType : u32 {
Undefined = 0, Undefined = 0,
ReadMemory = 1, ReadMemory = 1,
WriteMemory = 2, WriteMemory = 2,
SendKey = 3,
SendSignal = 4
}; };
struct PacketHeader { struct PacketHeader {
@ -69,9 +71,6 @@ public:
} }
private: private:
void HandleReadMemory(u32 address, u32 data_size);
void HandleWriteMemory(u32 address, std::span<const u8> data);
struct PacketHeader header; struct PacketHeader header;
std::array<u8, MAX_PACKET_DATA_SIZE> packet_data; std::array<u8, MAX_PACKET_DATA_SIZE> packet_data;

View File

@ -7,6 +7,8 @@
#include "core/memory.h" #include "core/memory.h"
#include "core/rpc/packet.h" #include "core/rpc/packet.h"
#include "core/rpc/rpc_server.h" #include "core/rpc/rpc_server.h"
#include "input_common/keyboard.h"
#include "input_common/main.h"
namespace Core::RPC { namespace Core::RPC {
@ -45,6 +47,24 @@ void RPCServer::HandleWriteMemory(Packet& packet, u32 address, std::span<const u
packet.SendReply(); packet.SendReply();
} }
void RPCServer::HandleSendKey(Packet& packet, u32 key_code, u8 state) {
if (state == 0) {
InputCommon::GetKeyboard()->ReleaseKey(key_code);
} else if(state == 1) {
InputCommon::GetKeyboard()->PressKey(key_code);
}
packet.SetPacketDataSize(0);
packet.SendReply();
}
void RPCServer::HandleSendSignal(Packet& packet, u32 signal_code, u32 signal_parameter) {
system.SendSignal(static_cast<Core::System::Signal>(signal_code), signal_parameter);
packet.SetPacketDataSize(0);
packet.SendReply();
}
bool RPCServer::ValidatePacket(const PacketHeader& packet_header) { bool RPCServer::ValidatePacket(const PacketHeader& packet_header) {
if (packet_header.version <= CURRENT_VERSION) { if (packet_header.version <= CURRENT_VERSION) {
switch (packet_header.packet_type) { switch (packet_header.packet_type) {
@ -54,6 +74,16 @@ bool RPCServer::ValidatePacket(const PacketHeader& packet_header) {
return true; return true;
} }
break; break;
case PacketType::SendKey:
if (packet_header.packet_size >= (sizeof(u32) + sizeof(u8))) {
return true;
}
break;
case PacketType::SendSignal:
if (packet_header.packet_size >= sizeof(u32)) {
return true;
}
break;
default: default:
break; break;
} }
@ -66,26 +96,40 @@ void RPCServer::HandleSingleRequest(std::unique_ptr<Packet> request_packet) {
const auto packet_data = request_packet->GetPacketData(); const auto packet_data = request_packet->GetPacketData();
if (ValidatePacket(request_packet->GetHeader())) { if (ValidatePacket(request_packet->GetHeader())) {
// Currently, all request types use the address/data_size wire format
u32 address = 0; u32 address = 0;
u32 data_size = 0; u32 data_size = 0;
std::memcpy(&address, packet_data.data(), sizeof(address)); u32 key_code = 0;
std::memcpy(&data_size, packet_data.data() + sizeof(address), sizeof(data_size)); u8 key_state = 0;
u32 signal_code = 0;
u32 signal_parameter = 0;
switch (request_packet->GetPacketType()) { switch (request_packet->GetPacketType()) {
case PacketType::ReadMemory: case PacketType::ReadMemory:
std::memcpy(&address, packet_data.data(), sizeof(address));
std::memcpy(&data_size, packet_data.data() + sizeof(address), sizeof(data_size));
if (data_size > 0 && data_size <= MAX_READ_SIZE) { if (data_size > 0 && data_size <= MAX_READ_SIZE) {
HandleReadMemory(*request_packet, address, data_size); HandleReadMemory(*request_packet, address, data_size);
success = true; success = true;
} }
break;
case PacketType::WriteMemory: case PacketType::WriteMemory:
std::memcpy(&address, packet_data.data(), sizeof(address));
std::memcpy(&data_size, packet_data.data() + sizeof(address), sizeof(data_size));
if (data_size > 0 && data_size <= MAX_PACKET_DATA_SIZE - (sizeof(u32) * 2)) { if (data_size > 0 && data_size <= MAX_PACKET_DATA_SIZE - (sizeof(u32) * 2)) {
const auto data = packet_data.subspan(sizeof(u32) * 2, data_size); const auto data = packet_data.subspan(sizeof(u32) * 2, data_size);
HandleWriteMemory(*request_packet, address, data); HandleWriteMemory(*request_packet, address, data);
success = true; success = true;
} }
break; break;
case PacketType::SendKey:
std::memcpy(&key_code, packet_data.data(), sizeof(key_code));
std::memcpy(&key_state, packet_data.data() + sizeof(key_code), sizeof(key_state));
HandleSendKey(*request_packet, key_code, key_state);
success = true;
break;
case PacketType::SendSignal:
std::memcpy(&signal_code, packet_data.data(), sizeof(signal_code));
std::memcpy(&signal_parameter, packet_data.data() + sizeof(signal_code), sizeof(signal_parameter));
HandleSendSignal(*request_packet, signal_code, signal_parameter);
break;
default: default:
break; break;
} }

View File

@ -29,6 +29,8 @@ public:
private: private:
void HandleReadMemory(Packet& packet, u32 address, u32 data_size); void HandleReadMemory(Packet& packet, u32 address, u32 data_size);
void HandleWriteMemory(Packet& packet, u32 address, std::span<const u8> data); void HandleWriteMemory(Packet& packet, u32 address, std::span<const u8> data);
void HandleSendKey(Packet& packet, u32 key_code, u8 state);
void HandleSendSignal(Packet& packet, u32 signal_code, u32 signal_parameter);
bool ValidatePacket(const PacketHeader& packet_header); bool ValidatePacket(const PacketHeader& packet_header);
void HandleSingleRequest(std::unique_ptr<Packet> request); void HandleSingleRequest(std::unique_ptr<Packet> request);
void HandleRequestsLoop(std::stop_token stop_token); void HandleRequestsLoop(std::stop_token stop_token);