Azahar-Mirror/ArticProtocol
1
0
Fork 0
mirror of https://github.com/azahar-emu/ArticProtocol synced 2025-11-07 07:30:03 +01:00
Code Issues Packages Projects Releases Wiki Activity

Properly name namespaces

Browse Source
This commit is contained in:
PabloMK7 2025-03-06 17:38:30 +01:00
parent e97b76505a
commit faa3a2d621
4 changed files with 46 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
includes/ArticFunctions.hpp
View File

@ -6,7 +6,7 @@
#include "memory.h" #include "memory.h"
#include "string" #include "string"
namespace ArticBaseFunctions { namespace ArticFunctions {
// All method handlers should be defined here // All method handlers should be defined here
extern std::map<std::string, void(*)(ArticProtocolServer::MethodInterface& out)> functionHandlers; extern std::map<std::string, void(*)(ArticProtocolServer::MethodInterface& out)> functionHandlers;

2
includes/ArticProtocolCommon.hpp
View File

@ -2,7 +2,7 @@
#include <3ds/types.h> #include <3ds/types.h>
#include <array> #include <array>
namespace ArticBaseCommon { namespace ArticProtocolCommon {
enum class MethodState : int { enum class MethodState : int {
PARSING_INPUT = 0, PARSING_INPUT = 0,
PARAMETER_TYPE_MISMATCH = 1, PARAMETER_TYPE_MISMATCH = 1,

20
includes/ArticProtocolServer.hpp
View File

@ -42,8 +42,8 @@ private:
class Request { class Request {
public: public:
ArticBaseCommon::RequestPacket reqPacket; ArticProtocolCommon::RequestPacket reqPacket;
std::vector<ArticBaseCommon::RequestParameter> reqParameters; std::vector<ArticProtocolCommon::RequestParameter> reqParameters;
}; };
static constexpr const char* VERSION = "2"; static constexpr const char* VERSION = "2";
@ -60,7 +60,7 @@ private:
public: public:
class MethodInterface { class MethodInterface {
public: public:
using MethodState = ArticBaseCommon::MethodState; using MethodState = ArticProtocolCommon::MethodState;
MethodInterface(Request& _req, void* _workBuffer, size_t _workBufferSize, int& _socketFD) : req(_req), workBuffer(_workBuffer, _workBufferSize), socketFD(_socketFD) {}; MethodInterface(Request& _req, void* _workBuffer, size_t _workBufferSize, int& _socketFD) : req(_req), workBuffer(_workBuffer, _workBufferSize), socketFD(_socketFD) {};
@ -82,8 +82,8 @@ public:
return true; return true;
} }
ArticBaseCommon::Buffer* ReserveResultBuffer(u32 bufferID, size_t resultBuffSize); ArticProtocolCommon::Buffer* ReserveResultBuffer(u32 bufferID, size_t resultBuffSize);
ArticBaseCommon::Buffer* ResizeLastResultBuffer(ArticBaseCommon::Buffer* buffer, size_t newSize); ArticProtocolCommon::Buffer* ResizeLastResultBuffer(ArticProtocolCommon::Buffer* buffer, size_t newSize);
void FinishGood(int returnValue); void FinishGood(int returnValue);
void FinishInternalError(); void FinishInternalError();
@ -117,13 +117,13 @@ public:
return offset; return offset;
} }
ArticBaseCommon::Buffer* Reserve(u32 bufferID, u32 bufferSize) { ArticProtocolCommon::Buffer* Reserve(u32 bufferID, u32 bufferSize) {
if (offset + sizeof(ArticBaseCommon::Buffer) + bufferSize > workBufferSize) { if (offset + sizeof(ArticProtocolCommon::Buffer) + bufferSize > workBufferSize) {
logger.Error("o=0x%08X, bs=0x%08X, wbs=0x%08X", offset, bufferSize, workBufferSize); logger.Error("o=0x%08X, bs=0x%08X, wbs=0x%08X", offset, bufferSize, workBufferSize);
return nullptr; return nullptr;
} }
ArticBaseCommon::Buffer* buf = (ArticBaseCommon::Buffer*)((uintptr_t)workBuffer + offset); ArticProtocolCommon::Buffer* buf = (ArticProtocolCommon::Buffer*)((uintptr_t)workBuffer + offset);
offset += sizeof(ArticBaseCommon::Buffer) + bufferSize; offset += sizeof(ArticProtocolCommon::Buffer) + bufferSize;
buf->bufferID = bufferID; buf->bufferID = bufferID;
buf->bufferSize = bufferSize; buf->bufferSize = bufferSize;
return buf; return buf;
@ -134,7 +134,7 @@ public:
INPUT_ERROR, INPUT_ERROR,
OUT_OF_MEMORY, OUT_OF_MEMORY,
}; };
ResizeState ResizeLast(ArticBaseCommon::Buffer* buffer, size_t newSize); ResizeState ResizeLast(ArticProtocolCommon::Buffer* buffer, size_t newSize);
std::pair<void*, size_t> GetRaw() { std::pair<void*, size_t> GetRaw() {
return std::make_pair(workBuffer, Size()); return std::make_pair(workBuffer, Size());

68
sources/ArticProtocolServer.cpp
View File

@ -41,8 +41,8 @@ ArticProtocolServer::~ArticProtocolServer() {
} }
void ArticProtocolServer::Serve() { void ArticProtocolServer::Serve() {
ArticBaseCommon::RequestPacket req; ArticProtocolCommon::RequestPacket req;
std::array<ArticBaseCommon::RequestParameter, MAX_PARAM_AMOUNT> params; std::array<ArticProtocolCommon::RequestParameter, MAX_PARAM_AMOUNT> params;
int retryCount = 0; int retryCount = 0;
while (run && !stopQueried) { while (run && !stopQueried) {
if (!Read(socketFd, &req, sizeof(req))) { if (!Read(socketFd, &req, sizeof(req))) {
@ -64,7 +64,7 @@ void ArticProtocolServer::Serve() {
// Process special method now, delegate otherwise // Process special method now, delegate otherwise
if (methodArray[0] == '$') { if (methodArray[0] == '$') {
logger.Debug("Server: Processing %s (rID %d)", methodArray.data(), req.requestID); logger.Debug("Server: Processing %s (rID %d)", methodArray.data(), req.requestID);
ArticBaseCommon::DataPacket resp{}; ArticProtocolCommon::DataPacket resp{};
resp.requestID = req.requestID; resp.requestID = req.requestID;
std::string_view method(methodArray.data()); std::string_view method(methodArray.data());
if (method == "$PING") { if (method == "$PING") {
@ -98,7 +98,7 @@ void ArticProtocolServer::Serve() {
u32 readParams = 0; u32 readParams = 0;
if (req.parameterCount) { if (req.parameterCount) {
if (req.parameterCount <= MAX_PARAM_AMOUNT) { if (req.parameterCount <= MAX_PARAM_AMOUNT) {
if (!Read(socketFd, params.data(), req.parameterCount * sizeof(ArticBaseCommon::RequestParameter))) { if (!Read(socketFd, params.data(), req.parameterCount * sizeof(ArticProtocolCommon::RequestParameter))) {
if (run) logger.Error("Server: Error reading from socket"); if (run) logger.Error("Server: Error reading from socket");
continue; continue;
} }
@ -111,7 +111,7 @@ void ArticProtocolServer::Serve() {
{ {
CTRPluginFramework::Lock l(pendingRequestsMutex); CTRPluginFramework::Lock l(pendingRequestsMutex);
pendingRequests.push(Request{.reqPacket = req, .reqParameters = std::vector<ArticBaseCommon::RequestParameter>(params.begin(), params.begin() + readParams)}); pendingRequests.push(Request{.reqPacket = req, .reqParameters = std::vector<ArticProtocolCommon::RequestParameter>(params.begin(), params.begin() + readParams)});
} }
LightEvent_Signal(&newPendingRequest); LightEvent_Signal(&newPendingRequest);
} }
@ -380,14 +380,14 @@ void ArticProtocolServer::RequestHandler::Serve() {
server->pendingRequests.pop(); server->pendingRequests.pop();
} }
ArticBaseCommon::DataPacket respPacket{}; ArticProtocolCommon::DataPacket respPacket{};
respPacket.requestID = req.reqPacket.requestID; respPacket.requestID = req.reqPacket.requestID;
std::array<char, sizeof(req.reqPacket.method) + 1> methodArray = {0}; std::array<char, sizeof(req.reqPacket.method) + 1> methodArray = {0};
memcpy(methodArray.data(), req.reqPacket.method.data(), req.reqPacket.method.size()); memcpy(methodArray.data(), req.reqPacket.method.data(), req.reqPacket.method.size());
auto it = ArticBaseFunctions::functionHandlers.find(std::string(methodArray.data())); auto it = ArticFunctions::functionHandlers.find(std::string(methodArray.data()));
if (it == ArticBaseFunctions::functionHandlers.end()) { if (it == ArticFunctions::functionHandlers.end()) {
respPacket.resp.articResult = ArticBaseCommon::ResponseMethod::ArticResult::METHOD_NOT_FOUND; respPacket.resp.articResult = ArticProtocolCommon::ResponseMethod::ArticResult::METHOD_NOT_FOUND;
logger.Error("Worker %d: Method not found: %s", id, methodArray.data()); logger.Error("Worker %d: Method not found: %s", id, methodArray.data());
if (!Write(accept_fd, &respPacket, sizeof(respPacket))) { if (!Write(accept_fd, &respPacket, sizeof(respPacket))) {
if (run) if (run)
@ -401,9 +401,9 @@ void ArticProtocolServer::RequestHandler::Serve() {
MethodInterface mi(req, workBuffer, workBufferSize, accept_fd); MethodInterface mi(req, workBuffer, workBufferSize, accept_fd);
it->second(mi); it->second(mi);
ArticBaseCommon::MethodState mState = mi.GetMethodState(); ArticProtocolCommon::MethodState mState = mi.GetMethodState();
if (mState != ArticBaseCommon::MethodState::FINISHED) { if (mState != ArticProtocolCommon::MethodState::FINISHED) {
respPacket.resp.articResult = ArticBaseCommon::ResponseMethod::ArticResult::METHOD_ERROR; respPacket.resp.articResult = ArticProtocolCommon::ResponseMethod::ArticResult::METHOD_ERROR;
logger.Error("Worker %d: %s method error: %d", id, methodArray.data(), mState); logger.Error("Worker %d: %s method error: %d", id, methodArray.data(), mState);
respPacket.resp.methodResult = (int)mState; respPacket.resp.methodResult = (int)mState;
if (!Write(accept_fd, &respPacket, sizeof(respPacket))) { if (!Write(accept_fd, &respPacket, sizeof(respPacket))) {
@ -412,7 +412,7 @@ void ArticProtocolServer::RequestHandler::Serve() {
return; return;
} }
} else { } else {
respPacket.resp.articResult = ArticBaseCommon::ResponseMethod::ArticResult::SUCCESS; respPacket.resp.articResult = ArticProtocolCommon::ResponseMethod::ArticResult::SUCCESS;
respPacket.resp.methodResult = mi.GetMethodReturnValue(); respPacket.resp.methodResult = mi.GetMethodReturnValue();
auto outBuffer = mi.GetOutputBuffer(); auto outBuffer = mi.GetOutputBuffer();
respPacket.resp.bufferSize = outBuffer.second; respPacket.resp.bufferSize = outBuffer.second;
@ -441,9 +441,9 @@ bool ArticProtocolServer::MethodInterface::GetParameterS8(s8& out) {
return false; return false;
} }
ArticBaseCommon::RequestParameter& currParam = req.reqParameters[currParameter++]; ArticProtocolCommon::RequestParameter& currParam = req.reqParameters[currParameter++];
if (currParam.type == ArticBaseCommon::RequestParameterType::IN_INTEGER_8) { if (currParam.type == ArticProtocolCommon::RequestParameterType::IN_INTEGER_8) {
out = *(s8*)currParam.data; out = *(s8*)currParam.data;
return true; return true;
} }
@ -461,9 +461,9 @@ bool ArticProtocolServer::MethodInterface::GetParameterS16(s16& out) {
return false; return false;
} }
ArticBaseCommon::RequestParameter& currParam = req.reqParameters[currParameter++]; ArticProtocolCommon::RequestParameter& currParam = req.reqParameters[currParameter++];
if (currParam.type == ArticBaseCommon::RequestParameterType::IN_INTEGER_16) { if (currParam.type == ArticProtocolCommon::RequestParameterType::IN_INTEGER_16) {
out = *(s16*)currParam.data; out = *(s16*)currParam.data;
return true; return true;
} }
@ -481,9 +481,9 @@ bool ArticProtocolServer::MethodInterface::GetParameterS32(s32& out) {
return false; return false;
} }
ArticBaseCommon::RequestParameter& currParam = req.reqParameters[currParameter++]; ArticProtocolCommon::RequestParameter& currParam = req.reqParameters[currParameter++];
if (currParam.type == ArticBaseCommon::RequestParameterType::IN_INTEGER_32) { if (currParam.type == ArticProtocolCommon::RequestParameterType::IN_INTEGER_32) {
out = *(s32*)currParam.data; out = *(s32*)currParam.data;
return true; return true;
} }
@ -501,9 +501,9 @@ bool ArticProtocolServer::MethodInterface::GetParameterS64(s64& out) {
return false; return false;
} }
ArticBaseCommon::RequestParameter& currParam = req.reqParameters[currParameter++]; ArticProtocolCommon::RequestParameter& currParam = req.reqParameters[currParameter++];
if (currParam.type == ArticBaseCommon::RequestParameterType::IN_INTEGER_64) { if (currParam.type == ArticProtocolCommon::RequestParameterType::IN_INTEGER_64) {
out = *(s64*)currParam.data; out = *(s64*)currParam.data;
return true; return true;
} }
@ -521,24 +521,24 @@ bool ArticProtocolServer::MethodInterface::GetParameterBuffer(void*& outBuff, si
return false; return false;
} }
ArticBaseCommon::RequestParameter& currParam = req.reqParameters[currParameter++]; ArticProtocolCommon::RequestParameter& currParam = req.reqParameters[currParameter++];
if (currParam.type == ArticBaseCommon::RequestParameterType::IN_SMALL_BUFFER) { if (currParam.type == ArticProtocolCommon::RequestParameterType::IN_SMALL_BUFFER) {
outBuff = currParam.data; outBuff = currParam.data;
outSize = currParam.parameterSize; outSize = currParam.parameterSize;
return true; return true;
} else if (currParam.type == ArticBaseCommon::RequestParameterType::IN_BIG_BUFFER) { } else if (currParam.type == ArticProtocolCommon::RequestParameterType::IN_BIG_BUFFER) {
// Perform request for buffer // Perform request for buffer
size_t bufferSize = *(size_t*)currParam.data; size_t bufferSize = *(size_t*)currParam.data;
ArticBaseCommon::Buffer* buf = workBuffer.Reserve(currParam.bigBufferID, bufferSize); ArticProtocolCommon::Buffer* buf = workBuffer.Reserve(currParam.bigBufferID, bufferSize);
if (buf == nullptr) { if (buf == nullptr) {
state = MethodState::OUT_OF_MEMORY; state = MethodState::OUT_OF_MEMORY;
return false; return false;
} }
ArticBaseCommon::DataPacket dataPacket{}; ArticProtocolCommon::DataPacket dataPacket{};
dataPacket.requestID = req.reqPacket.requestID; dataPacket.requestID = req.reqPacket.requestID;
dataPacket.resp.articResult = ArticBaseCommon::ResponseMethod::ArticResult::PROVIDE_INPUT; dataPacket.resp.articResult = ArticProtocolCommon::ResponseMethod::ArticResult::PROVIDE_INPUT;
dataPacket.resp.provideInputBufferID = currParam.bigBufferID; dataPacket.resp.provideInputBufferID = currParam.bigBufferID;
dataPacket.resp.bufferSize = (int)bufferSize; dataPacket.resp.bufferSize = (int)bufferSize;
@ -553,7 +553,7 @@ bool ArticProtocolServer::MethodInterface::GetParameterBuffer(void*& outBuff, si
} }
if (dataPacket.requestID != req.reqPacket.requestID || if (dataPacket.requestID != req.reqPacket.requestID ||
dataPacket.resp.articResult != ArticBaseCommon::ResponseMethod::ArticResult::PROVIDE_INPUT || dataPacket.resp.articResult != ArticProtocolCommon::ResponseMethod::ArticResult::PROVIDE_INPUT ||
dataPacket.resp.provideInputBufferID != currParam.bigBufferID || dataPacket.resp.provideInputBufferID != currParam.bigBufferID ||
dataPacket.resp.bufferSize != (int)bufferSize) { dataPacket.resp.bufferSize != (int)bufferSize) {
@ -573,7 +573,7 @@ bool ArticProtocolServer::MethodInterface::GetParameterBuffer(void*& outBuff, si
return false; return false;
} }
ArticBaseCommon::Buffer* ArticProtocolServer::MethodInterface::ReserveResultBuffer(u32 bufferID, size_t resultBuffSize) { ArticProtocolCommon::Buffer* ArticProtocolServer::MethodInterface::ReserveResultBuffer(u32 bufferID, size_t resultBuffSize) {
if (state != MethodState::GENERATING_OUTPUT) { if (state != MethodState::GENERATING_OUTPUT) {
if (state == MethodState::PARSING_INPUT) { if (state == MethodState::PARSING_INPUT) {
state = MethodState::UNEXPECTED_PARSING_INPUT; state = MethodState::UNEXPECTED_PARSING_INPUT;
@ -581,7 +581,7 @@ ArticBaseCommon::Buffer* ArticProtocolServer::MethodInterface::ReserveResultBuff
return nullptr; return nullptr;
} }
ArticBaseCommon::Buffer* buf = workBuffer.Reserve(bufferID, resultBuffSize); ArticProtocolCommon::Buffer* buf = workBuffer.Reserve(bufferID, resultBuffSize);
if (buf == nullptr) { if (buf == nullptr) {
state = MethodState::OUT_OF_MEMORY_OUTPUT; state = MethodState::OUT_OF_MEMORY_OUTPUT;
return nullptr; return nullptr;
@ -589,7 +589,7 @@ ArticBaseCommon::Buffer* ArticProtocolServer::MethodInterface::ReserveResultBuff
return buf; return buf;
} }
ArticBaseCommon::Buffer* ArticProtocolServer::MethodInterface::ResizeLastResultBuffer(ArticBaseCommon::Buffer* buffer, size_t newSize) { ArticProtocolCommon::Buffer* ArticProtocolServer::MethodInterface::ResizeLastResultBuffer(ArticProtocolCommon::Buffer* buffer, size_t newSize) {
if (state != MethodState::GENERATING_OUTPUT) { if (state != MethodState::GENERATING_OUTPUT) {
if (state == MethodState::PARSING_INPUT) { if (state == MethodState::PARSING_INPUT) {
state = MethodState::UNEXPECTED_PARSING_INPUT; state = MethodState::UNEXPECTED_PARSING_INPUT;
@ -620,15 +620,15 @@ void ArticProtocolServer::MethodInterface::FinishInternalError() {
return; return;
} }
ArticProtocolServer::MethodInterface::WorkBufferHandler::ResizeState ArticProtocolServer::MethodInterface::WorkBufferHandler::ResizeLast(ArticBaseCommon::Buffer* buffer, size_t newSize) { ArticProtocolServer::MethodInterface::WorkBufferHandler::ResizeState ArticProtocolServer::MethodInterface::WorkBufferHandler::ResizeLast(ArticProtocolCommon::Buffer* buffer, size_t newSize) {
if (buffer->bufferSize == newSize) if (buffer->bufferSize == newSize)
return ResizeState::GOOD; return ResizeState::GOOD;
if ((uintptr_t)workBuffer + offset != (uintptr_t)buffer + buffer->bufferSize + sizeof(ArticBaseCommon::Buffer)) if ((uintptr_t)workBuffer + offset != (uintptr_t)buffer + buffer->bufferSize + sizeof(ArticProtocolCommon::Buffer))
return ResizeState::INPUT_ERROR; return ResizeState::INPUT_ERROR;
int sizeDiff = newSize - buffer->bufferSize; int sizeDiff = newSize - buffer->bufferSize;
if (newSize == 0) { if (newSize == 0) {
// Remove the buffer completely // Remove the buffer completely
sizeDiff -= sizeof(ArticBaseCommon::Buffer); sizeDiff -= sizeof(ArticProtocolCommon::Buffer);
} }
if (offset + sizeDiff > workBufferSize) if (offset + sizeDiff > workBufferSize)
return ResizeState::OUT_OF_MEMORY; return ResizeState::OUT_OF_MEMORY;