emu-mirror/Lime3DS
1
0
Fork 0
mirror of https://github.com/Lime3DS/Lime3DS.git synced 2025-03-13 09:12:27 +01:00
Code Issues Packages Projects Releases Wiki Activity

SendKey & SendSignal over rpc server

Browse Source
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
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
src/core/rpc/packet.h
View File

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

54
src/core/rpc/rpc_server.cpp
View File

@ -7,6 +7,8 @@
#include "core/memory.h"
#include "core/rpc/packet.h"
#include "core/rpc/rpc_server.h"
#include "input_common/keyboard.h"
#include "input_common/main.h"
namespace Core::RPC {
@ -45,6 +47,24 @@ void RPCServer::HandleWriteMemory(Packet& packet, u32 address, std::span<const u
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) {
if (packet_header.version <= CURRENT_VERSION) {
switch (packet_header.packet_type) {
@ -54,6 +74,16 @@ bool RPCServer::ValidatePacket(const PacketHeader& packet_header) {
return true;
}
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:
break;
}
@ -66,26 +96,40 @@ void RPCServer::HandleSingleRequest(std::unique_ptr<Packet> request_packet) {
const auto packet_data = request_packet->GetPacketData();
if (ValidatePacket(request_packet->GetHeader())) {
// Currently, all request types use the address/data_size wire format
u32 address = 0;
u32 data_size = 0;
std::memcpy(&address, packet_data.data(), sizeof(address));
std::memcpy(&data_size, packet_data.data() + sizeof(address), sizeof(data_size));
u32 key_code = 0;
u8 key_state = 0;
u32 signal_code = 0;
u32 signal_parameter = 0;
switch (request_packet->GetPacketType()) {
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) {
HandleReadMemory(*request_packet, address, data_size);
success = true;
}
break;
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)) {
const auto data = packet_data.subspan(sizeof(u32) * 2, data_size);
HandleWriteMemory(*request_packet, address, data);
success = true;
}
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:
break;
}

2
src/core/rpc/rpc_server.h
View File

@ -29,6 +29,8 @@ public:
private:
void HandleReadMemory(Packet& packet, u32 address, u32 data_size);
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);
void HandleSingleRequest(std::unique_ptr<Packet> request);
void HandleRequestsLoop(std::stop_token stop_token);