1
0
Fork 0
mirror of https://github.com/Atmosphere-NX/Atmosphere.git synced 2024-11-13 23:46:40 +00:00
Atmosphere/stratosphere/TioServer/source/tio_file_server.cpp

159 lines
6.5 KiB
C++
Raw Normal View History

2021-02-24 15:16:41 +00:00
/*
* Copyright (c) 2018-2020 Atmosphère-NX
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stratosphere.hpp>
#include "tio_file_server.hpp"
#include "tio_file_server_packet.hpp"
#include "tio_file_server_htcs_server.hpp"
#include "tio_file_server_processor.hpp"
#include "tio_sd_card_observer.hpp"
2021-02-24 15:16:41 +00:00
namespace ams::tio {
namespace {
constexpr inline auto NumDispatchThreads = 2;
constexpr inline auto DispatchThreadPriority = 21;
constexpr inline size_t RequestBufferSize = 1_MB + util::AlignUp(0x40 + fs::EntryNameLengthMax, 1_KB);
struct FileServerRequest {
int socket;
FileServerRequestHeader header;
u8 body[RequestBufferSize];
};
constexpr const char HtcsPortName[] = "iywys@$TioServer_FileServer";
alignas(os::ThreadStackAlignment) u8 g_server_stack[os::MemoryPageSize];
alignas(os::ThreadStackAlignment) u8 g_observer_stack[os::MemoryPageSize];
2021-02-24 15:16:41 +00:00
alignas(os::ThreadStackAlignment) u8 g_dispatch_stacks[NumDispatchThreads][os::MemoryPageSize];
constinit FileServerHtcsServer g_file_server_htcs_server;
constinit FileServerProcessor g_file_server_processor(g_file_server_htcs_server);
constinit SdCardObserver g_sd_card_observer;
2021-02-24 15:16:41 +00:00
constinit os::ThreadType g_file_server_dispatch_threads[NumDispatchThreads];
constinit FileServerRequest g_requests[NumDispatchThreads];
constinit os::MessageQueueType g_free_mq;
constinit os::MessageQueueType g_dispatch_mq;
constinit uintptr_t g_free_mq_storage[NumDispatchThreads];
constinit uintptr_t g_dispatch_mq_storage[NumDispatchThreads];
void OnSdCardInsertionChanged(bool inserted) {
g_file_server_processor.SetInserted(inserted);
}
2021-02-24 15:16:41 +00:00
void OnFileServerHtcsSocketAccepted(int fd) {
/* Service requests, while we can. */
while (true) {
/* Receive a free request. */
uintptr_t request_address;
os::ReceiveMessageQueue(std::addressof(request_address), std::addressof(g_free_mq));
/* Ensure we manage our request properly. */
auto req_guard = SCOPE_GUARD { os::SendMessageQueue(std::addressof(g_free_mq), request_address); };
/* Receive the request header. */
FileServerRequest *request = reinterpret_cast<FileServerRequest *>(request_address);
if (htcs::Recv(fd, std::addressof(request->header), sizeof(request->header), htcs::HTCS_MSG_WAITALL) != sizeof(request->header)) {
break;
}
/* Receive the request body, if necessary. */
if (request->header.body_size > 0) {
2021-02-24 18:12:25 +00:00
if (htcs::Recv(fd, request->body, request->header.body_size, htcs::HTCS_MSG_WAITALL) != request->header.body_size) {
2021-02-24 15:16:41 +00:00
break;
}
}
/* Dispatch the request. */
req_guard.Cancel();
request->socket = fd;
os::SendMessageQueue(std::addressof(g_dispatch_mq), request_address);
}
/* Our socket is no longer making requests, so close it. */
htcs::Close(fd);
/* Clean up any server resources. */
g_file_server_processor.Unmount();
}
void FileServerDispatchThreadFunction(void *) {
while (true) {
/* Receive a request. */
uintptr_t request_address;
os::ReceiveMessageQueue(std::addressof(request_address), std::addressof(g_dispatch_mq));
/* Process the request. */
FileServerRequest *request = reinterpret_cast<FileServerRequest *>(request_address);
if (!g_file_server_processor.ProcessRequest(std::addressof(request->header), request->body, request->socket)) {
htcs::Close(request->socket);
}
/* Free the request. */
os::SendMessageQueue(std::addressof(g_free_mq), request_address);
}
}
}
void InitializeFileServer() {
/* Initialize the htcs server. */
g_file_server_htcs_server.Initialize(HtcsPortName, g_server_stack, sizeof(g_server_stack), OnFileServerHtcsSocketAccepted);
/* Initialize SD card observer. */
g_sd_card_observer.Initialize(g_observer_stack, sizeof(g_observer_stack));
g_sd_card_observer.SetCallback(OnSdCardInsertionChanged);
2021-02-24 15:16:41 +00:00
/* Initialize the command processor. */
g_file_server_processor.SetInserted(g_sd_card_observer.IsSdCardInserted());
2021-02-24 15:16:41 +00:00
g_file_server_processor.SetRequestBufferSize(RequestBufferSize);
/* Initialize the dispatch message queues. */
os::InitializeMessageQueue(std::addressof(g_free_mq), g_free_mq_storage, util::size(g_free_mq_storage));
os::InitializeMessageQueue(std::addressof(g_dispatch_mq), g_dispatch_mq_storage, util::size(g_dispatch_mq_storage));
/* Begin with all requests free. */
for (auto i = 0; i < NumDispatchThreads; ++i) {
os::SendMessageQueue(std::addressof(g_free_mq), reinterpret_cast<uintptr_t>(g_requests + i));
}
/* Initialize the dispatch threads. */
/* NOTE: Nintendo does not name these threads. */
for (auto i = 0; i < NumDispatchThreads; ++i) {
R_ABORT_UNLESS(os::CreateThread(g_file_server_dispatch_threads + i, FileServerDispatchThreadFunction, nullptr, g_dispatch_stacks + i, sizeof(g_dispatch_stacks[i]), DispatchThreadPriority));
}
}
void StartFileServer() {
/* Start the htcs server. */
g_file_server_htcs_server.Start();
/* Start the dispatch threads. */
for (auto i = 0; i < NumDispatchThreads; ++i) {
os::StartThread(g_file_server_dispatch_threads + i);
}
}
void WaitFileServer() {
/* Wait for the htcs server to finish. */
g_file_server_htcs_server.Wait();
}
}