Revert "hoc-clk: add live vdd2, live boost clock and basic pwm dimming"
This reverts commit 15b7df8ef1.
This commit is contained in:
souldbminersmwc
@@ -1,31 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 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 "htcs_impl.hpp"
|
||||
|
||||
namespace ams::htcs::impl {
|
||||
|
||||
namespace {
|
||||
|
||||
constexpr const htcs::HtcsPeerName PeerNameAny = {""};
|
||||
constexpr const htcs::HtcsPeerName DefaultHostName = {""};
|
||||
|
||||
}
|
||||
|
||||
const htcs::HtcsPeerName GetPeerNameAny() { return PeerNameAny; }
|
||||
const htcs::HtcsPeerName GetDefaultHostName() { return DefaultHostName; }
|
||||
|
||||
}
|
||||
@@ -1,24 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 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/>.
|
||||
*/
|
||||
#pragma once
|
||||
#include <stratosphere.hpp>
|
||||
|
||||
namespace ams::htcs::impl {
|
||||
|
||||
const htcs::HtcsPeerName GetPeerNameAny();
|
||||
const htcs::HtcsPeerName GetDefaultHostName();
|
||||
|
||||
}
|
||||
@@ -1,398 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 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 "htcs_manager.hpp"
|
||||
#include "htcs_manager_impl.hpp"
|
||||
#include "htcs_util.hpp"
|
||||
|
||||
namespace ams::htcs::impl {
|
||||
|
||||
HtcsManager::HtcsManager(mem::StandardAllocator *allocator, htclow::HtclowManager *htclow_manager) : m_allocator(allocator), m_impl(static_cast<HtcsManagerImpl *>(allocator->Allocate(sizeof(HtcsManagerImpl), alignof(HtcsManagerImpl)))) {
|
||||
std::construct_at(m_impl, m_allocator, htclow_manager);
|
||||
}
|
||||
|
||||
HtcsManager::~HtcsManager() {
|
||||
std::destroy_at(m_impl);
|
||||
m_allocator->Free(m_impl);
|
||||
}
|
||||
|
||||
os::EventType *HtcsManager::GetServiceAvailabilityEvent() {
|
||||
return m_impl->GetServiceAvailabilityEvent();
|
||||
}
|
||||
|
||||
bool HtcsManager::IsServiceAvailable() {
|
||||
return m_impl->IsServiceAvailable();
|
||||
}
|
||||
|
||||
void HtcsManager::Socket(s32 *out_err, s32 *out_desc, bool enable_disconnection_emulation) {
|
||||
/* Invoke our implementation. */
|
||||
s32 err = -1, desc = -1;
|
||||
const Result result = m_impl->CreateSocket(std::addressof(err), std::addressof(desc), enable_disconnection_emulation);
|
||||
|
||||
/* Set output. */
|
||||
if (R_SUCCEEDED(result)) {
|
||||
*out_err = err;
|
||||
if (err == 0) {
|
||||
*out_desc = desc;
|
||||
} else {
|
||||
*out_desc = -1;
|
||||
}
|
||||
} else {
|
||||
*out_err = ConvertResultToErrorCode(result);
|
||||
*out_desc = -1;
|
||||
}
|
||||
}
|
||||
|
||||
void HtcsManager::Close(s32 *out_err, s32 *out_res, s32 desc) {
|
||||
/* Invoke our implementation. */
|
||||
const Result result = m_impl->DestroySocket(desc);
|
||||
|
||||
/* Set output. */
|
||||
*out_err = ConvertResultToErrorCode(result);
|
||||
if (R_SUCCEEDED(result)) {
|
||||
*out_res = 0;
|
||||
} else {
|
||||
*out_res = -1;
|
||||
}
|
||||
}
|
||||
|
||||
void HtcsManager::Connect(s32 *out_err, s32 *out_res, const SockAddrHtcs &address, s32 desc) {
|
||||
/* Invoke our implementation. */
|
||||
s32 err = -1;
|
||||
const Result result = m_impl->Connect(std::addressof(err), desc, address);
|
||||
|
||||
/* Set output. */
|
||||
if (R_SUCCEEDED(result)) {
|
||||
*out_err = err;
|
||||
if (err == 0) {
|
||||
*out_res = 0;
|
||||
} else {
|
||||
*out_res = -1;
|
||||
}
|
||||
} else {
|
||||
*out_err = ConvertResultToErrorCode(result);
|
||||
*out_res = -1;
|
||||
}
|
||||
}
|
||||
|
||||
void HtcsManager::Bind(s32 *out_err, s32 *out_res, const SockAddrHtcs &address, s32 desc) {
|
||||
/* Invoke our implementation. */
|
||||
s32 err = -1;
|
||||
const Result result = m_impl->Bind(std::addressof(err), desc, address);
|
||||
|
||||
/* Set output. */
|
||||
if (R_SUCCEEDED(result)) {
|
||||
*out_err = err;
|
||||
if (err == 0) {
|
||||
*out_res = 0;
|
||||
} else {
|
||||
*out_res = -1;
|
||||
}
|
||||
} else {
|
||||
*out_err = ConvertResultToErrorCode(result);
|
||||
*out_res = -1;
|
||||
}
|
||||
}
|
||||
|
||||
void HtcsManager::Listen(s32 *out_err, s32 *out_res, s32 backlog_count, s32 desc) {
|
||||
/* Invoke our implementation. */
|
||||
s32 err = -1;
|
||||
const Result result = m_impl->Listen(std::addressof(err), desc, backlog_count);
|
||||
|
||||
/* Set output. */
|
||||
if (R_SUCCEEDED(result)) {
|
||||
*out_err = err;
|
||||
if (err == 0) {
|
||||
*out_res = 0;
|
||||
} else {
|
||||
*out_res = -1;
|
||||
}
|
||||
} else {
|
||||
*out_err = ConvertResultToErrorCode(result);
|
||||
*out_res = -1;
|
||||
}
|
||||
}
|
||||
|
||||
void HtcsManager::Recv(s32 *out_err, s64 *out_size, char *buffer, size_t size, s32 flags, s32 desc) {
|
||||
/* Invoke our implementation. */
|
||||
s32 err = -1;
|
||||
s64 recv_size = -1;
|
||||
const Result result = m_impl->Receive(std::addressof(err), std::addressof(recv_size), buffer, size, desc, flags);
|
||||
|
||||
/* Set output. */
|
||||
if (R_SUCCEEDED(result)) {
|
||||
*out_err = err;
|
||||
if (err == 0) {
|
||||
*out_size = recv_size;
|
||||
} else {
|
||||
*out_size = -1;
|
||||
}
|
||||
} else {
|
||||
*out_err = ConvertResultToErrorCode(result);
|
||||
*out_size = -1;
|
||||
}
|
||||
}
|
||||
|
||||
void HtcsManager::Send(s32 *out_err, s64 *out_size, const char *buffer, size_t size, s32 flags, s32 desc) {
|
||||
/* Invoke our implementation. */
|
||||
s32 err = -1;
|
||||
s64 send_size = -1;
|
||||
const Result result = m_impl->Send(std::addressof(err), std::addressof(send_size), buffer, size, desc, flags);
|
||||
|
||||
/* Set output. */
|
||||
if (R_SUCCEEDED(result)) {
|
||||
*out_err = err;
|
||||
if (err == 0) {
|
||||
*out_size = send_size;
|
||||
} else {
|
||||
*out_size = -1;
|
||||
}
|
||||
} else {
|
||||
*out_err = ConvertResultToErrorCode(result);
|
||||
*out_size = -1;
|
||||
}
|
||||
}
|
||||
|
||||
void HtcsManager::Shutdown(s32 *out_err, s32 *out_res, s32 how, s32 desc) {
|
||||
/* Invoke our implementation. */
|
||||
s32 err = -1;
|
||||
const Result result = m_impl->Shutdown(std::addressof(err), desc, how);
|
||||
|
||||
/* Set output. */
|
||||
if (R_SUCCEEDED(result)) {
|
||||
*out_err = err;
|
||||
if (err == 0) {
|
||||
*out_res = 0;
|
||||
} else {
|
||||
*out_res = -1;
|
||||
}
|
||||
} else {
|
||||
if (htcs::ResultInvalidHandle::Includes(result)) {
|
||||
*out_err = HTCS_ENOTCONN;
|
||||
} else {
|
||||
*out_err = ConvertResultToErrorCode(result);
|
||||
}
|
||||
*out_res = -1;
|
||||
}
|
||||
}
|
||||
|
||||
void HtcsManager::Fcntl(s32 *out_err, s32 *out_res, s32 command, s32 value, s32 desc) {
|
||||
/* Invoke our implementation. */
|
||||
s32 err = -1, res = -1;
|
||||
const Result result = m_impl->Fcntl(std::addressof(err), std::addressof(res), desc, command, value);
|
||||
|
||||
/* Set output. */
|
||||
if (R_SUCCEEDED(result)) {
|
||||
*out_err = err;
|
||||
*out_res = res;
|
||||
} else {
|
||||
*out_err = ConvertResultToErrorCode(result);
|
||||
*out_res = -1;
|
||||
}
|
||||
}
|
||||
|
||||
Result HtcsManager::AcceptStart(u32 *out_task_id, os::NativeHandle *out_handle, s32 desc) {
|
||||
R_RETURN(m_impl->AcceptStart(out_task_id, out_handle, desc));
|
||||
}
|
||||
|
||||
void HtcsManager::AcceptResults(s32 *out_err, s32 *out_desc, SockAddrHtcs *out_address, u32 task_id, s32 desc) {
|
||||
/* Invoke our implementation. */
|
||||
s32 err = -1;
|
||||
const Result result = m_impl->AcceptResults(std::addressof(err), out_desc, out_address, task_id, desc);
|
||||
|
||||
/* Set output. */
|
||||
if (R_SUCCEEDED(result)) {
|
||||
*out_err = err;
|
||||
} else {
|
||||
if (htc::ResultCancelled::Includes(result)) {
|
||||
*out_err = HTCS_ENETDOWN;
|
||||
} else if (htc::ResultTaskQueueNotAvailable::Includes(result)) {
|
||||
*out_err = HTCS_EINTR;
|
||||
} else {
|
||||
*out_err = ConvertResultToErrorCode(result);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Result HtcsManager::RecvStart(u32 *out_task_id, os::NativeHandle *out_handle, s64 size, s32 desc, s32 flags) {
|
||||
R_RETURN(m_impl->RecvStart(out_task_id, out_handle, size, desc, flags));
|
||||
}
|
||||
|
||||
void HtcsManager::RecvResults(s32 *out_err, s64 *out_size, char *buffer, s64 buffer_size, u32 task_id, s32 desc) {
|
||||
/* Invoke our implementation. */
|
||||
s32 err = -1;
|
||||
s64 size = -1;
|
||||
const Result result = m_impl->RecvResults(std::addressof(err), std::addressof(size), buffer, buffer_size, task_id, desc);
|
||||
|
||||
/* Set output. */
|
||||
if (R_SUCCEEDED(result)) {
|
||||
*out_err = err;
|
||||
if (err == 0) {
|
||||
*out_size = size;
|
||||
} else {
|
||||
*out_size = -1;
|
||||
}
|
||||
} else {
|
||||
if (htc::ResultTaskQueueNotAvailable::Includes(result)) {
|
||||
*out_err = HTCS_EINTR;
|
||||
} else {
|
||||
*out_err = ConvertResultToErrorCode(result);
|
||||
}
|
||||
*out_size = -1;
|
||||
}
|
||||
}
|
||||
|
||||
Result HtcsManager::SendStart(u32 *out_task_id, os::NativeHandle *out_handle, const char *buffer, s64 size, s32 desc, s32 flags) {
|
||||
R_RETURN(m_impl->SendStart(out_task_id, out_handle, buffer, size, desc, flags));
|
||||
}
|
||||
|
||||
Result HtcsManager::SendLargeStart(u32 *out_task_id, os::NativeHandle *out_handle, const char **buffers, const s64 *sizes, s32 count, s32 desc, s32 flags) {
|
||||
R_RETURN(m_impl->SendLargeStart(out_task_id, out_handle, buffers, sizes, count, desc, flags));
|
||||
}
|
||||
|
||||
void HtcsManager::SendResults(s32 *out_err, s64 *out_size, u32 task_id, s32 desc) {
|
||||
/* Invoke our implementation. */
|
||||
s32 err = -1;
|
||||
s64 size = -1;
|
||||
const Result result = m_impl->SendResults(std::addressof(err), std::addressof(size), task_id, desc);
|
||||
|
||||
/* Set output. */
|
||||
if (R_SUCCEEDED(result)) {
|
||||
*out_err = err;
|
||||
if (err == 0) {
|
||||
*out_size = size;
|
||||
} else {
|
||||
*out_size = -1;
|
||||
}
|
||||
} else {
|
||||
if (htc::ResultTaskQueueNotAvailable::Includes(result)) {
|
||||
*out_err = HTCS_EINTR;
|
||||
} else {
|
||||
*out_err = ConvertResultToErrorCode(result);
|
||||
}
|
||||
*out_size = -1;
|
||||
}
|
||||
}
|
||||
|
||||
Result HtcsManager::StartSend(u32 *out_task_id, os::NativeHandle *out_handle, s32 desc, s64 size, s32 flags) {
|
||||
R_RETURN(m_impl->StartSend(out_task_id, out_handle, desc, size, flags));
|
||||
}
|
||||
|
||||
Result HtcsManager::ContinueSend(s64 *out_size, const char *buffer, s64 buffer_size, u32 task_id, s32 desc) {
|
||||
/* Invoke our implementation. */
|
||||
s64 size = -1;
|
||||
R_TRY_CATCH(m_impl->ContinueSend(std::addressof(size), buffer, buffer_size, task_id, desc)) {
|
||||
R_CONVERT(htclow::ResultInvalidChannelState, tma::ResultUnknown())
|
||||
R_CONVERT(htc::ResultTaskCancelled, tma::ResultUnknown())
|
||||
} R_END_TRY_CATCH;
|
||||
|
||||
/* Set output. */
|
||||
*out_size = size;
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
void HtcsManager::EndSend(s32 *out_err, s64 *out_size, u32 task_id, s32 desc) {
|
||||
/* Invoke our implementation. */
|
||||
s32 err = -1;
|
||||
s64 size = -1;
|
||||
const Result result = m_impl->EndSend(std::addressof(err), std::addressof(size), task_id, desc);
|
||||
|
||||
/* Set output. */
|
||||
if (R_SUCCEEDED(result)) {
|
||||
*out_err = err;
|
||||
if (err == 0) {
|
||||
*out_size = size;
|
||||
} else {
|
||||
*out_size = -1;
|
||||
}
|
||||
} else {
|
||||
if (htc::ResultTaskQueueNotAvailable::Includes(result)) {
|
||||
*out_err = HTCS_EINTR;
|
||||
} else {
|
||||
*out_err = ConvertResultToErrorCode(result);
|
||||
}
|
||||
*out_size = -1;
|
||||
}
|
||||
}
|
||||
|
||||
Result HtcsManager::StartRecv(u32 *out_task_id, os::NativeHandle *out_handle, s64 size, s32 desc, s32 flags) {
|
||||
R_RETURN(m_impl->StartRecv(out_task_id, out_handle, size, desc, flags));
|
||||
}
|
||||
|
||||
void HtcsManager::EndRecv(s32 *out_err, s64 *out_size, char *buffer, s64 buffer_size, u32 task_id, s32 desc) {
|
||||
/* Invoke our implementation. */
|
||||
s32 err = -1;
|
||||
s64 size = -1;
|
||||
const Result result = m_impl->EndRecv(std::addressof(err), std::addressof(size), buffer, buffer_size, task_id, desc);
|
||||
|
||||
/* Set output. */
|
||||
if (R_SUCCEEDED(result)) {
|
||||
*out_err = err;
|
||||
if (err == 0) {
|
||||
*out_size = size;
|
||||
} else {
|
||||
*out_size = -1;
|
||||
}
|
||||
} else {
|
||||
if (htc::ResultCancelled::Includes(result) || htc::ResultTaskQueueNotAvailable::Includes(result)) {
|
||||
*out_err = 0;
|
||||
} else {
|
||||
*out_err = ConvertResultToErrorCode(result);
|
||||
}
|
||||
*out_size = -1;
|
||||
}
|
||||
}
|
||||
|
||||
Result HtcsManager::StartSelect(u32 *out_task_id, os::NativeHandle *out_handle, Span<const int> read_handles, Span<const int> write_handles, Span<const int> exception_handles, s64 tv_sec, s64 tv_usec) {
|
||||
/* Invoke our implementation. */
|
||||
R_TRY_CATCH(m_impl->StartSelect(out_task_id, out_handle, read_handles, write_handles, exception_handles, tv_sec, tv_usec)) {
|
||||
R_CONVERT(htc::ResultTaskCancelled, tma::ResultUnknown())
|
||||
} R_END_TRY_CATCH;
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result HtcsManager::EndSelect(s32 *out_err, s32 *out_count, Span<int> read_handles, Span<int> write_handles, Span<int> exception_handles, u32 task_id) {
|
||||
/* Invoke our implementation. */
|
||||
s32 err = -1;
|
||||
bool empty = false;
|
||||
const Result result = m_impl->EndSelect(std::addressof(err), std::addressof(empty), read_handles, write_handles, exception_handles, task_id);
|
||||
|
||||
/* Set output. */
|
||||
if (R_SUCCEEDED(result) && !empty) {
|
||||
*out_err = err;
|
||||
if (err == 0) {
|
||||
const auto num_read = std::count_if(read_handles.begin(), read_handles.end(), [](int handle) { return handle != 0; });
|
||||
const auto num_write = std::count_if(write_handles.begin(), write_handles.end(), [](int handle) { return handle != 0; });
|
||||
const auto num_exception = std::count_if(exception_handles.begin(), exception_handles.end(), [](int handle) { return handle != 0; });
|
||||
*out_count = num_read + num_write + num_exception;
|
||||
} else {
|
||||
*out_count = -1;
|
||||
}
|
||||
} else {
|
||||
if (R_SUCCEEDED(result)) {
|
||||
*out_err = 0;
|
||||
*out_count = 0;
|
||||
} else {
|
||||
*out_err = ConvertResultToErrorCode(err);
|
||||
*out_count = -1;
|
||||
}
|
||||
}
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,67 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 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/>.
|
||||
*/
|
||||
#pragma once
|
||||
#include <stratosphere.hpp>
|
||||
#include "../../htclow/htclow_manager.hpp"
|
||||
|
||||
namespace ams::htcs::impl {
|
||||
|
||||
class HtcsManagerImpl;
|
||||
|
||||
class HtcsManager {
|
||||
private:
|
||||
mem::StandardAllocator *m_allocator;
|
||||
HtcsManagerImpl *m_impl;
|
||||
public:
|
||||
HtcsManager(mem::StandardAllocator *allocator, htclow::HtclowManager *htclow_manager);
|
||||
~HtcsManager();
|
||||
public:
|
||||
os::EventType *GetServiceAvailabilityEvent();
|
||||
|
||||
bool IsServiceAvailable();
|
||||
public:
|
||||
void Socket(s32 *out_err, s32 *out_desc, bool enable_disconnection_emulation);
|
||||
void Close(s32 *out_err, s32 *out_res, s32 desc);
|
||||
void Connect(s32 *out_err, s32 *out_res, const SockAddrHtcs &address, s32 desc);
|
||||
void Bind(s32 *out_err, s32 *out_res, const SockAddrHtcs &address, s32 desc);
|
||||
void Listen(s32 *out_err, s32 *out_res, s32 backlog_count, s32 desc);
|
||||
void Recv(s32 *out_err, s64 *out_size, char *buffer, size_t size, s32 flags, s32 desc);
|
||||
void Send(s32 *out_err, s64 *out_size, const char *buffer, size_t size, s32 flags, s32 desc);
|
||||
void Shutdown(s32 *out_err, s32 *out_res, s32 how, s32 desc);
|
||||
void Fcntl(s32 *out_err, s32 *out_res, s32 command, s32 value, s32 desc);
|
||||
|
||||
Result AcceptStart(u32 *out_task_id, os::NativeHandle *out_handle, s32 desc);
|
||||
void AcceptResults(s32 *out_err, s32 *out_desc, SockAddrHtcs *out_address, u32 task_id, s32 desc);
|
||||
|
||||
Result RecvStart(u32 *out_task_id, os::NativeHandle *out_handle, s64 size, s32 desc, s32 flags);
|
||||
void RecvResults(s32 *out_err, s64 *out_size, char *buffer, s64 buffer_size, u32 task_id, s32 desc);
|
||||
|
||||
Result SendStart(u32 *out_task_id, os::NativeHandle *out_handle, const char *buffer, s64 size, s32 desc, s32 flags);
|
||||
Result SendLargeStart(u32 *out_task_id, os::NativeHandle *out_handle, const char **buffers, const s64 *sizes, s32 count, s32 desc, s32 flags);
|
||||
void SendResults(s32 *out_err, s64 *out_size, u32 task_id, s32 desc);
|
||||
|
||||
Result StartSend(u32 *out_task_id, os::NativeHandle *out_handle, s32 desc, s64 size, s32 flags);
|
||||
Result ContinueSend(s64 *out_size, const char *buffer, s64 buffer_size, u32 task_id, s32 desc);
|
||||
void EndSend(s32 *out_err, s64 *out_size, u32 task_id, s32 desc);
|
||||
|
||||
Result StartRecv(u32 *out_task_id, os::NativeHandle *out_handle, s64 size, s32 desc, s32 flags);
|
||||
void EndRecv(s32 *out_err, s64 *out_size, char *buffer, s64 buffer_size, u32 task_id, s32 desc);
|
||||
|
||||
Result StartSelect(u32 *out_task_id, os::NativeHandle *out_handle, Span<const int> read_handles, Span<const int> write_handles, Span<const int> exception_handles, s64 tv_sec, s64 tv_usec);
|
||||
Result EndSelect(s32 *out_err, s32 *out_count, Span<int> read_handles, Span<int> write_handles, Span<int> exception_handles, u32 task_id);
|
||||
};
|
||||
|
||||
}
|
||||
@@ -1,79 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 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 "htcs_manager.hpp"
|
||||
|
||||
namespace ams::htcs::impl::HtcsManagerHolder {
|
||||
|
||||
namespace {
|
||||
|
||||
constinit os::SdkMutex g_holder_mutex;
|
||||
constinit int g_holder_reference_count = 0;
|
||||
|
||||
mem::StandardAllocator g_allocator;
|
||||
|
||||
constinit HtcsManager *g_manager = nullptr;
|
||||
|
||||
alignas(os::MemoryPageSize) u8 g_heap_buffer[416_KB];
|
||||
|
||||
}
|
||||
|
||||
void AddReference() {
|
||||
std::scoped_lock lk(g_holder_mutex);
|
||||
|
||||
if ((g_holder_reference_count++) == 0) {
|
||||
/* Add reference to the htclow manager. */
|
||||
htclow::HtclowManagerHolder::AddReference();
|
||||
|
||||
/* Initialize the allocator for the manager. */
|
||||
g_allocator.Initialize(g_heap_buffer, sizeof(g_heap_buffer));
|
||||
|
||||
/* Allocate the manager. */
|
||||
g_manager = static_cast<HtcsManager *>(g_allocator.Allocate(sizeof(HtcsManager), alignof(HtcsManager)));
|
||||
|
||||
/* Construct the manager. */
|
||||
std::construct_at(g_manager, std::addressof(g_allocator), htclow::HtclowManagerHolder::GetHtclowManager());
|
||||
}
|
||||
|
||||
AMS_ASSERT(g_holder_reference_count > 0);
|
||||
}
|
||||
|
||||
void Release() {
|
||||
std::scoped_lock lk(g_holder_mutex);
|
||||
|
||||
AMS_ASSERT(g_holder_reference_count > 0);
|
||||
|
||||
if ((--g_holder_reference_count) == 0) {
|
||||
/* Destroy the manager. */
|
||||
std::destroy_at(g_manager);
|
||||
g_allocator.Free(g_manager);
|
||||
g_manager = nullptr;
|
||||
|
||||
/* Finalize the allocator. */
|
||||
g_allocator.Finalize();
|
||||
|
||||
/* Release reference to the htclow manager. */
|
||||
htclow::HtclowManagerHolder::Release();
|
||||
}
|
||||
}
|
||||
|
||||
HtcsManager *GetHtcsManager() {
|
||||
std::scoped_lock lk(g_holder_mutex);
|
||||
|
||||
return g_manager;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,189 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 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 "htcs_manager.hpp"
|
||||
#include "htcs_manager_impl.hpp"
|
||||
|
||||
namespace ams::htcs::impl {
|
||||
|
||||
HtcsManagerImpl::HtcsManagerImpl(mem::StandardAllocator *allocator, htclow::HtclowManager *htclow_manager)
|
||||
: m_allocator(allocator),
|
||||
m_driver(htclow_manager, htclow::ModuleId::Htcs),
|
||||
m_driver_manager(std::addressof(m_driver)),
|
||||
m_rpc_client(m_allocator, std::addressof(m_driver), HtcsClientChannelId),
|
||||
m_data_channel_manager(std::addressof(m_rpc_client), htclow_manager),
|
||||
m_service(m_allocator, m_driver_manager.GetDriver(), std::addressof(m_rpc_client), std::addressof(m_data_channel_manager)),
|
||||
m_monitor(m_allocator, m_driver_manager.GetDriver(), std::addressof(m_rpc_client), std::addressof(m_service))
|
||||
{
|
||||
/* Start the monitor. */
|
||||
m_monitor.Start();
|
||||
}
|
||||
|
||||
HtcsManagerImpl::~HtcsManagerImpl() {
|
||||
/* Cancel our monitor. */
|
||||
m_monitor.Cancel();
|
||||
m_monitor.Wait();
|
||||
}
|
||||
|
||||
os::EventType *HtcsManagerImpl::GetServiceAvailabilityEvent() {
|
||||
return m_monitor.GetServiceAvailabilityEvent();
|
||||
}
|
||||
|
||||
bool HtcsManagerImpl::IsServiceAvailable() {
|
||||
return m_monitor.IsServiceAvailable();
|
||||
}
|
||||
|
||||
Result HtcsManagerImpl::CreateSocket(s32 *out_err, s32 *out_desc, bool enable_disconnection_emulation) {
|
||||
R_RETURN(m_service.CreateSocket(out_err, out_desc, enable_disconnection_emulation));
|
||||
}
|
||||
|
||||
Result HtcsManagerImpl::DestroySocket(s32 desc) {
|
||||
R_RETURN(m_service.DestroySocket(desc));
|
||||
}
|
||||
|
||||
Result HtcsManagerImpl::Connect(s32 *out_err, s32 desc, const SockAddrHtcs &address) {
|
||||
R_RETURN(m_service.Connect(out_err, desc, address));
|
||||
}
|
||||
|
||||
Result HtcsManagerImpl::Bind(s32 *out_err, s32 desc, const SockAddrHtcs &address) {
|
||||
R_RETURN(m_service.Bind(out_err, desc, address));
|
||||
}
|
||||
|
||||
Result HtcsManagerImpl::Listen(s32 *out_err, s32 desc, s32 backlog_count) {
|
||||
R_RETURN(m_service.Listen(out_err, desc, backlog_count));
|
||||
}
|
||||
|
||||
Result HtcsManagerImpl::Receive(s32 *out_err, s64 *out_size, char *buffer, size_t size, s32 desc, s32 flags) {
|
||||
R_RETURN(m_service.Receive(out_err, out_size, buffer, size, desc, flags));
|
||||
}
|
||||
|
||||
Result HtcsManagerImpl::Send(s32 *out_err, s64 *out_size, const char *buffer, size_t size, s32 desc, s32 flags) {
|
||||
R_RETURN(m_service.Send(out_err, out_size, buffer, size, desc, flags));
|
||||
}
|
||||
|
||||
Result HtcsManagerImpl::Shutdown(s32 *out_err, s32 desc, s32 how) {
|
||||
R_RETURN(m_service.Shutdown(out_err, desc, how));
|
||||
}
|
||||
|
||||
Result HtcsManagerImpl::Fcntl(s32 *out_err, s32 *out_res, s32 desc, s32 command, s32 value) {
|
||||
R_RETURN(m_service.Fcntl(out_err, out_res, desc, command, value));
|
||||
}
|
||||
|
||||
Result HtcsManagerImpl::AcceptStart(u32 *out_task_id, os::NativeHandle *out_handle, s32 desc) {
|
||||
R_RETURN(m_service.AcceptStart(out_task_id, out_handle, desc));
|
||||
}
|
||||
|
||||
Result HtcsManagerImpl::AcceptResults(s32 *out_err, s32 *out_desc, SockAddrHtcs *out_address, u32 task_id, s32 desc) {
|
||||
R_RETURN(m_service.AcceptResults(out_err, out_desc, out_address, task_id, desc));
|
||||
}
|
||||
|
||||
Result HtcsManagerImpl::RecvStart(u32 *out_task_id, os::NativeHandle *out_handle, s64 size, s32 desc, s32 flags) {
|
||||
R_RETURN(m_service.ReceiveSmallStart(out_task_id, out_handle, size, desc, flags));
|
||||
}
|
||||
|
||||
Result HtcsManagerImpl::RecvResults(s32 *out_err, s64 *out_size, char *buffer, s64 buffer_size, u32 task_id, s32 desc) {
|
||||
R_RETURN(m_service.ReceiveSmallResults(out_err, out_size, buffer, buffer_size, task_id, desc));
|
||||
}
|
||||
|
||||
Result HtcsManagerImpl::SendStart(u32 *out_task_id, os::NativeHandle *out_handle, const char *buffer, s64 size, s32 desc, s32 flags) {
|
||||
/* Start the send. */
|
||||
u32 task_id{};
|
||||
os::NativeHandle handle;
|
||||
R_TRY(m_service.SendSmallStart(std::addressof(task_id), std::addressof(handle), desc, size, flags));
|
||||
|
||||
/* Continue the send. */
|
||||
s64 continue_size;
|
||||
const Result result = m_service.SendSmallContinue(std::addressof(continue_size), buffer, size, task_id, desc);
|
||||
if (R_SUCCEEDED(result) || htcs::ResultCompleted::Includes(result) || htc::ResultTaskQueueNotAvailable::Includes(result)) {
|
||||
*out_task_id = task_id;
|
||||
*out_handle = handle;
|
||||
|
||||
R_SUCCEED();
|
||||
} else {
|
||||
os::SystemEventType event;
|
||||
os::AttachReadableHandleToSystemEvent(std::addressof(event), handle, true, os::EventClearMode_ManualClear);
|
||||
|
||||
s32 err;
|
||||
s64 rsize;
|
||||
m_service.SendSmallResults(std::addressof(err), std::addressof(rsize), task_id, desc);
|
||||
|
||||
os::DestroySystemEvent(std::addressof(event));
|
||||
|
||||
R_RETURN(result);
|
||||
}
|
||||
}
|
||||
|
||||
Result HtcsManagerImpl::SendLargeStart(u32 *out_task_id, os::NativeHandle *out_handle, const char **buffers, const s64 *sizes, s32 count, s32 desc, s32 flags) {
|
||||
/* NOTE: Nintendo aborts here, too. */
|
||||
AMS_UNUSED(out_task_id, out_handle, buffers, sizes, count, desc, flags);
|
||||
AMS_ABORT("HtcsManagerImpl::SendLargeStart is not implemented");
|
||||
}
|
||||
|
||||
Result HtcsManagerImpl::SendResults(s32 *out_err, s64 *out_size, u32 task_id, s32 desc) {
|
||||
R_RETURN(m_service.SendSmallResults(out_err, out_size, task_id, desc));
|
||||
}
|
||||
|
||||
Result HtcsManagerImpl::StartSend(u32 *out_task_id, os::NativeHandle *out_handle, s32 desc, s64 size, s32 flags) {
|
||||
R_RETURN(m_service.SendStart(out_task_id, out_handle, desc, size, flags));
|
||||
}
|
||||
|
||||
Result HtcsManagerImpl::ContinueSend(s64 *out_size, const char *buffer, s64 buffer_size, u32 task_id, s32 desc) {
|
||||
R_RETURN(m_service.SendContinue(out_size, buffer, buffer_size, task_id, desc));
|
||||
}
|
||||
|
||||
Result HtcsManagerImpl::EndSend(s32 *out_err, s64 *out_size, u32 task_id, s32 desc) {
|
||||
R_RETURN(m_service.SendResults(out_err, out_size, task_id, desc));
|
||||
}
|
||||
|
||||
Result HtcsManagerImpl::StartRecv(u32 *out_task_id, os::NativeHandle *out_handle, s64 size, s32 desc, s32 flags) {
|
||||
R_RETURN(m_service.ReceiveStart(out_task_id, out_handle, size, desc, flags));
|
||||
}
|
||||
|
||||
Result HtcsManagerImpl::EndRecv(s32 *out_err, s64 *out_size, char *buffer, s64 buffer_size, u32 task_id, s32 desc) {
|
||||
R_RETURN(m_service.ReceiveResults(out_err, out_size, buffer, buffer_size, task_id, desc));
|
||||
}
|
||||
|
||||
Result HtcsManagerImpl::StartSelect(u32 *out_task_id, os::NativeHandle *out_handle, Span<const int> read_handles, Span<const int> write_handles, Span<const int> exception_handles, s64 tv_sec, s64 tv_usec) {
|
||||
/* Start the select. */
|
||||
u32 task_id{};
|
||||
os::NativeHandle handle = os::InvalidNativeHandle;
|
||||
const Result result = m_service.SelectStart(std::addressof(task_id), std::addressof(handle), read_handles, write_handles, exception_handles, tv_sec, tv_usec);
|
||||
|
||||
/* Ensure our state ends up clean. */
|
||||
if (htcs::ResultCancelled::Includes(result)) {
|
||||
s32 err;
|
||||
bool empty;
|
||||
m_service.SelectEnd(std::addressof(err), std::addressof(empty), Span<int>{}, Span<int>{}, Span<int>{}, task_id);
|
||||
|
||||
if (handle != os::InvalidNativeHandle) {
|
||||
os::SystemEventType event;
|
||||
os::AttachReadableHandleToSystemEvent(std::addressof(event), handle, true, os::EventClearMode_ManualClear);
|
||||
|
||||
os::DestroySystemEvent(std::addressof(event));
|
||||
}
|
||||
} else if (R_SUCCEEDED(result)) {
|
||||
*out_task_id = task_id;
|
||||
*out_handle = handle;
|
||||
}
|
||||
|
||||
R_RETURN(result);
|
||||
}
|
||||
|
||||
Result HtcsManagerImpl::EndSelect(s32 *out_err, bool *out_empty, Span<int> read_handles, Span<int> write_handles, Span<int> exception_handles, u32 task_id) {
|
||||
R_RETURN(m_service.SelectEnd(out_err, out_empty, read_handles, write_handles, exception_handles, task_id));
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,76 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 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/>.
|
||||
*/
|
||||
#pragma once
|
||||
#include <stratosphere.hpp>
|
||||
#include "../../htclow/htclow_manager.hpp"
|
||||
#include "../../htc/server/driver/htc_htclow_driver.hpp"
|
||||
#include "../../htc/server/driver/htc_driver_manager.hpp"
|
||||
#include "../../htc/server/rpc/htc_rpc_client.hpp"
|
||||
#include "rpc/htcs_data_channel_manager.hpp"
|
||||
#include "htcs_service.hpp"
|
||||
#include "htcs_monitor.hpp"
|
||||
|
||||
namespace ams::htcs::impl {
|
||||
|
||||
class HtcsManagerImpl {
|
||||
private:
|
||||
mem::StandardAllocator *m_allocator;
|
||||
htc::server::driver::HtclowDriver m_driver;
|
||||
htc::server::driver::DriverManager m_driver_manager;
|
||||
htc::server::rpc::RpcClient m_rpc_client;
|
||||
rpc::DataChannelManager m_data_channel_manager;
|
||||
HtcsService m_service;
|
||||
HtcsMonitor m_monitor;
|
||||
public:
|
||||
HtcsManagerImpl(mem::StandardAllocator *allocator, htclow::HtclowManager *htclow_manager);
|
||||
~HtcsManagerImpl();
|
||||
public:
|
||||
os::EventType *GetServiceAvailabilityEvent();
|
||||
|
||||
bool IsServiceAvailable();
|
||||
public:
|
||||
Result CreateSocket(s32 *out_err, s32 *out_desc, bool enable_disconnection_emulation);
|
||||
Result DestroySocket(s32 desc);
|
||||
Result Connect(s32 *out_err, s32 desc, const SockAddrHtcs &address);
|
||||
Result Bind(s32 *out_err, s32 desc, const SockAddrHtcs &address);
|
||||
Result Listen(s32 *out_err, s32 desc, s32 backlog_count);
|
||||
Result Receive(s32 *out_err, s64 *out_size, char *buffer, size_t size, s32 desc, s32 flags);
|
||||
Result Send(s32 *out_err, s64 *out_size, const char *buffer, size_t size, s32 desc, s32 flags);
|
||||
Result Shutdown(s32 *out_err, s32 desc, s32 how);
|
||||
Result Fcntl(s32 *out_err, s32 *out_res, s32 desc, s32 command, s32 value);
|
||||
|
||||
Result AcceptStart(u32 *out_task_id, os::NativeHandle *out_handle, s32 desc);
|
||||
Result AcceptResults(s32 *out_err, s32 *out_desc, SockAddrHtcs *out_address, u32 task_id, s32 desc);
|
||||
|
||||
Result RecvStart(u32 *out_task_id, os::NativeHandle *out_handle, s64 size, s32 desc, s32 flags);
|
||||
Result RecvResults(s32 *out_err, s64 *out_size, char *buffer, s64 buffer_size, u32 task_id, s32 desc);
|
||||
|
||||
Result SendStart(u32 *out_task_id, os::NativeHandle *out_handle, const char *buffer, s64 size, s32 desc, s32 flags);
|
||||
Result SendLargeStart(u32 *out_task_id, os::NativeHandle *out_handle, const char **buffers, const s64 *sizes, s32 count, s32 desc, s32 flags);
|
||||
Result SendResults(s32 *out_err, s64 *out_size, u32 task_id, s32 desc);
|
||||
|
||||
Result StartSend(u32 *out_task_id, os::NativeHandle *out_handle, s32 desc, s64 size, s32 flags);
|
||||
Result ContinueSend(s64 *out_size, const char *buffer, s64 buffer_size, u32 task_id, s32 desc);
|
||||
Result EndSend(s32 *out_err, s64 *out_size, u32 task_id, s32 desc);
|
||||
|
||||
Result StartRecv(u32 *out_task_id, os::NativeHandle *out_handle, s64 size, s32 desc, s32 flags);
|
||||
Result EndRecv(s32 *out_err, s64 *out_size, char *buffer, s64 buffer_size, u32 task_id, s32 desc);
|
||||
|
||||
Result StartSelect(u32 *out_task_id, os::NativeHandle *out_handle, Span<const int> read_handles, Span<const int> write_handles, Span<const int> exception_handles, s64 tv_sec, s64 tv_usec);
|
||||
Result EndSelect(s32 *out_err, bool *out_empty, Span<int> read_handles, Span<int> write_handles, Span<int> exception_handles, u32 task_id);
|
||||
};
|
||||
|
||||
}
|
||||
@@ -1,106 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 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 "htcs_manager.hpp"
|
||||
#include "htcs_manager_impl.hpp"
|
||||
|
||||
namespace ams::htcs::impl {
|
||||
|
||||
HtcsMonitor::HtcsMonitor(mem::StandardAllocator *allocator, htc::server::driver::IDriver *drv, htc::server::rpc::RpcClient *rc, HtcsService *srv)
|
||||
: m_allocator(allocator),
|
||||
m_driver(drv),
|
||||
m_rpc_client(rc),
|
||||
m_service(srv),
|
||||
m_monitor_thread_stack(m_allocator->Allocate(os::MemoryPageSize, os::ThreadStackAlignment)),
|
||||
m_mutex(),
|
||||
m_cancel_event(os::EventClearMode_ManualClear),
|
||||
m_service_availability_event(os::EventClearMode_ManualClear),
|
||||
m_cancelled(false),
|
||||
m_is_service_available(false)
|
||||
{
|
||||
/* ... */
|
||||
}
|
||||
|
||||
HtcsMonitor::~HtcsMonitor() {
|
||||
/* Free thread stack. */
|
||||
m_allocator->Free(m_monitor_thread_stack);
|
||||
}
|
||||
|
||||
void HtcsMonitor::Start() {
|
||||
/* Create the monitor thread. */
|
||||
R_ABORT_UNLESS(os::CreateThread(std::addressof(m_monitor_thread), ThreadEntry, this, m_monitor_thread_stack, os::MemoryPageSize, AMS_GET_SYSTEM_THREAD_PRIORITY(htc, HtcsMonitor)));
|
||||
|
||||
/* Set thread name. */
|
||||
os::SetThreadNamePointer(std::addressof(m_monitor_thread), AMS_GET_SYSTEM_THREAD_NAME(htc, HtcsMonitor));
|
||||
|
||||
/* Start the monitor thread. */
|
||||
os::StartThread(std::addressof(m_monitor_thread));
|
||||
}
|
||||
|
||||
void HtcsMonitor::Cancel() {
|
||||
/* Cancel, and signal. */
|
||||
m_cancelled = true;
|
||||
m_cancel_event.Signal();
|
||||
}
|
||||
|
||||
void HtcsMonitor::Wait() {
|
||||
/* Wait for the thread. */
|
||||
os::WaitThread(std::addressof(m_monitor_thread));
|
||||
os::DestroyThread(std::addressof(m_monitor_thread));
|
||||
}
|
||||
|
||||
void HtcsMonitor::ThreadBody() {
|
||||
/* Loop so long as we're not cancelled. */
|
||||
while (!m_cancelled) {
|
||||
/* Open the rpc client. */
|
||||
m_rpc_client->Open();
|
||||
|
||||
/* Ensure we close, if something goes wrong. */
|
||||
auto client_guard = SCOPE_GUARD { m_rpc_client->Close(); };
|
||||
|
||||
/* Wait for the rpc server. */
|
||||
if (m_rpc_client->WaitAny(htclow::ChannelState_Connectable, m_cancel_event.GetBase()) != 0) {
|
||||
break;
|
||||
}
|
||||
|
||||
/* Start the rpc client. */
|
||||
const Result start_result = m_rpc_client->Start();
|
||||
if (R_FAILED(start_result)) {
|
||||
/* DEBUG */
|
||||
R_ABORT_UNLESS(start_result);
|
||||
continue;
|
||||
}
|
||||
|
||||
/* We're available! */
|
||||
this->SetServiceAvailability(true);
|
||||
client_guard.Cancel();
|
||||
|
||||
/* We're available, so we want to cleanup when we're done. */
|
||||
ON_SCOPE_EXIT {
|
||||
m_rpc_client->Close();
|
||||
m_rpc_client->Cancel();
|
||||
m_rpc_client->Wait();
|
||||
this->SetServiceAvailability(false);
|
||||
};
|
||||
|
||||
/* Wait to become disconnected. */
|
||||
if (m_rpc_client->WaitAny(htclow::ChannelState_Disconnected, m_cancel_event.GetBase()) != 0) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,73 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 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/>.
|
||||
*/
|
||||
#pragma once
|
||||
#include <stratosphere.hpp>
|
||||
#include "../../htc/server/driver/htc_i_driver.hpp"
|
||||
#include "../../htc/server/rpc/htc_rpc_client.hpp"
|
||||
#include "htcs_service.hpp"
|
||||
|
||||
namespace ams::htcs::impl {
|
||||
|
||||
class HtcsMonitor {
|
||||
private:
|
||||
mem::StandardAllocator *m_allocator;
|
||||
htc::server::driver::IDriver *m_driver;
|
||||
htc::server::rpc::RpcClient *m_rpc_client;
|
||||
HtcsService *m_service;
|
||||
void *m_monitor_thread_stack;
|
||||
os::ThreadType m_monitor_thread;
|
||||
os::SdkMutex m_mutex;
|
||||
os::Event m_cancel_event;
|
||||
os::Event m_service_availability_event;
|
||||
bool m_cancelled;
|
||||
bool m_is_service_available;
|
||||
private:
|
||||
static void ThreadEntry(void *arg) {
|
||||
static_cast<HtcsMonitor *>(arg)->ThreadBody();
|
||||
}
|
||||
|
||||
void ThreadBody();
|
||||
public:
|
||||
HtcsMonitor(mem::StandardAllocator *allocator, htc::server::driver::IDriver *drv, htc::server::rpc::RpcClient *rc, HtcsService *srv);
|
||||
~HtcsMonitor();
|
||||
public:
|
||||
void Start();
|
||||
void Cancel();
|
||||
void Wait();
|
||||
|
||||
os::EventType *GetServiceAvailabilityEvent() { return m_service_availability_event.GetBase(); }
|
||||
|
||||
bool IsServiceAvailable() {
|
||||
/* Lock ourselves. */
|
||||
std::scoped_lock lk(m_mutex);
|
||||
|
||||
/* Get availability. */
|
||||
return m_is_service_available;
|
||||
}
|
||||
private:
|
||||
void SetServiceAvailability(bool available) {
|
||||
/* Lock ourselves. */
|
||||
std::scoped_lock lk(m_mutex);
|
||||
|
||||
/* Set availability. */
|
||||
m_is_service_available = available;
|
||||
|
||||
/* Signal availability change. */
|
||||
m_service_availability_event.Signal();
|
||||
}
|
||||
};
|
||||
|
||||
}
|
||||
@@ -1,413 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 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 "htcs_service.hpp"
|
||||
#include "rpc/htcs_rpc_tasks.hpp"
|
||||
#include "htcs_util.hpp"
|
||||
|
||||
namespace ams::htcs::impl {
|
||||
|
||||
void HtcsService::WaitTask(u32 task_id) {
|
||||
return m_rpc_client->Wait(task_id);
|
||||
}
|
||||
|
||||
Result HtcsService::CreateSocket(s32 *out_err, s32 *out_desc, bool enable_disconnection_emulation) {
|
||||
/* Set disconnection emulation enabled. */
|
||||
m_driver->SetDisconnectionEmulationEnabled(enable_disconnection_emulation);
|
||||
|
||||
/* Begin the task. */
|
||||
u32 task_id{};
|
||||
R_TRY(m_rpc_client->Begin<rpc::SocketTask>(std::addressof(task_id)));
|
||||
|
||||
/* Wait for the task to complete. */
|
||||
this->WaitTask(task_id);
|
||||
|
||||
/* Finish the task. */
|
||||
htcs::SocketError err;
|
||||
s32 desc;
|
||||
R_TRY(m_rpc_client->End<rpc::SocketTask>(task_id, std::addressof(err), std::addressof(desc)));
|
||||
|
||||
/* Set output. */
|
||||
*out_err = err;
|
||||
*out_desc = desc;
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result HtcsService::DestroySocket(s32 desc) {
|
||||
/* Begin the task. */
|
||||
u32 task_id{};
|
||||
R_TRY(m_rpc_client->Begin<rpc::CloseTask>(std::addressof(task_id), desc));
|
||||
|
||||
/* Wait for the task to complete. */
|
||||
this->WaitTask(task_id);
|
||||
|
||||
/* Cancel the socket. */
|
||||
m_rpc_client->CancelBySocket(desc);
|
||||
|
||||
/* Finish the task. */
|
||||
htcs::SocketError err;
|
||||
R_TRY(m_rpc_client->End<rpc::CloseTask>(task_id, std::addressof(err)));
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result HtcsService::Connect(s32 *out_err, s32 desc, const SockAddrHtcs &address) {
|
||||
/* Validate the address. */
|
||||
R_UNLESS(address.family == 0, htcs::ResultInvalidArgument());
|
||||
R_UNLESS(IsValidName(address.peer_name), htcs::ResultInvalidArgument());
|
||||
R_UNLESS(IsValidName(address.port_name), htcs::ResultInvalidArgument());
|
||||
|
||||
/* Begin the task. */
|
||||
u32 task_id{};
|
||||
R_TRY(m_rpc_client->Begin<rpc::ConnectTask>(std::addressof(task_id), desc, address.peer_name, address.port_name));
|
||||
|
||||
/* Wait for the task to complete. */
|
||||
this->WaitTask(task_id);
|
||||
|
||||
/* Finish the task. */
|
||||
htcs::SocketError err;
|
||||
R_TRY(m_rpc_client->End<rpc::ConnectTask>(task_id, std::addressof(err)));
|
||||
|
||||
/* Set output. */
|
||||
*out_err = err;
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result HtcsService::Bind(s32 *out_err, s32 desc, const SockAddrHtcs &address) {
|
||||
/* Validate the address. */
|
||||
R_UNLESS(address.family == 0, htcs::ResultInvalidArgument());
|
||||
R_UNLESS(IsValidName(address.peer_name), htcs::ResultInvalidArgument());
|
||||
R_UNLESS(IsValidName(address.port_name), htcs::ResultInvalidArgument());
|
||||
|
||||
/* Begin the task. */
|
||||
u32 task_id{};
|
||||
R_TRY(m_rpc_client->Begin<rpc::BindTask>(std::addressof(task_id), desc, address.peer_name, address.port_name));
|
||||
|
||||
/* Wait for the task to complete. */
|
||||
this->WaitTask(task_id);
|
||||
|
||||
/* Finish the task. */
|
||||
htcs::SocketError err;
|
||||
R_TRY(m_rpc_client->End<rpc::BindTask>(task_id, std::addressof(err)));
|
||||
|
||||
/* Set output. */
|
||||
*out_err = err;
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result HtcsService::Listen(s32 *out_err, s32 desc, s32 backlog_count) {
|
||||
/* Begin the task. */
|
||||
u32 task_id{};
|
||||
R_TRY(m_rpc_client->Begin<rpc::ListenTask>(std::addressof(task_id), desc, backlog_count));
|
||||
|
||||
/* Wait for the task to complete. */
|
||||
this->WaitTask(task_id);
|
||||
|
||||
/* Finish the task. */
|
||||
htcs::SocketError err;
|
||||
R_TRY(m_rpc_client->End<rpc::ListenTask>(task_id, std::addressof(err)));
|
||||
|
||||
/* Set output. */
|
||||
*out_err = err;
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result HtcsService::Receive(s32 *out_err, s64 *out_size, char *buffer, s64 size, s32 desc, s32 flags) {
|
||||
/* Begin the task. */
|
||||
u32 task_id{};
|
||||
R_TRY(m_rpc_client->Begin<rpc::ReceiveTask>(std::addressof(task_id), desc, size, static_cast<htcs::MessageFlag>(flags)));
|
||||
|
||||
/* Wait for the task to complete. */
|
||||
this->WaitTask(task_id);
|
||||
|
||||
/* Finish the task. */
|
||||
R_TRY(this->ReceiveResults(out_err, out_size, buffer, size, task_id, desc));
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result HtcsService::Send(s32 *out_err, s64 *out_size, const char *buffer, s64 size, s32 desc, s32 flags) {
|
||||
/* Begin the task. */
|
||||
u32 task_id{};
|
||||
R_TRY(m_rpc_client->Begin<rpc::SendTask>(std::addressof(task_id), desc, size, static_cast<htcs::MessageFlag>(flags)));
|
||||
|
||||
/* Send the data. */
|
||||
s64 cont_size;
|
||||
const Result result = this->SendContinue(std::addressof(cont_size), buffer, size, task_id, desc);
|
||||
if (R_FAILED(result)) {
|
||||
R_RETURN(this->SendResults(out_err, out_size, task_id, desc));
|
||||
}
|
||||
|
||||
/* Wait for the task to complete. */
|
||||
this->WaitTask(task_id);
|
||||
|
||||
/* Finish the task. */
|
||||
R_TRY(this->SendResults(out_err, out_size, task_id, desc));
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result HtcsService::Shutdown(s32 *out_err, s32 desc, s32 how) {
|
||||
/* Begin the task. */
|
||||
u32 task_id{};
|
||||
R_TRY(m_rpc_client->Begin<rpc::ShutdownTask>(std::addressof(task_id), desc, static_cast<htcs::ShutdownType>(how)));
|
||||
|
||||
/* Wait for the task to complete. */
|
||||
this->WaitTask(task_id);
|
||||
|
||||
/* Finish the task. */
|
||||
htcs::SocketError err;
|
||||
R_TRY(m_rpc_client->End<rpc::ShutdownTask>(task_id, std::addressof(err)));
|
||||
|
||||
/* Set output. */
|
||||
*out_err = err;
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result HtcsService::Fcntl(s32 *out_err, s32 *out_res, s32 desc, s32 command, s32 value) {
|
||||
/* Begin the task. */
|
||||
u32 task_id{};
|
||||
R_TRY(m_rpc_client->Begin<rpc::FcntlTask>(std::addressof(task_id), desc, command, value));
|
||||
|
||||
/* Wait for the task to complete. */
|
||||
this->WaitTask(task_id);
|
||||
|
||||
/* Finish the task. */
|
||||
htcs::SocketError err;
|
||||
s32 res;
|
||||
R_TRY(m_rpc_client->End<rpc::FcntlTask>(task_id, std::addressof(err), std::addressof(res)));
|
||||
|
||||
/* Set output. */
|
||||
*out_err = err;
|
||||
*out_res = res;
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result HtcsService::AcceptStart(u32 *out_task_id, os::NativeHandle *out_handle, s32 desc) {
|
||||
/* Begin the task. */
|
||||
u32 task_id{};
|
||||
R_TRY(m_rpc_client->Begin<rpc::AcceptTask>(std::addressof(task_id), desc));
|
||||
|
||||
/* Detach the task. */
|
||||
*out_task_id = task_id;
|
||||
*out_handle = m_rpc_client->DetachReadableHandle(task_id);
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result HtcsService::AcceptResults(s32 *out_err, s32 *out_desc, SockAddrHtcs *out_address, u32 task_id, s32 desc) {
|
||||
AMS_UNUSED(out_address);
|
||||
|
||||
/* Finish the task. */
|
||||
htcs::SocketError err;
|
||||
s32 ret_desc;
|
||||
R_TRY(m_rpc_client->End<rpc::AcceptTask>(task_id, std::addressof(err), std::addressof(ret_desc), desc));
|
||||
|
||||
/* Set output. */
|
||||
*out_err = err;
|
||||
*out_desc = ret_desc;
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result HtcsService::ReceiveSmallStart(u32 *out_task_id, os::NativeHandle *out_handle, s64 size, s32 desc, s32 flags) {
|
||||
/* Begin the task. */
|
||||
u32 task_id{};
|
||||
R_TRY(m_rpc_client->Begin<rpc::ReceiveSmallTask>(std::addressof(task_id), desc, size, static_cast<htcs::MessageFlag>(flags)));
|
||||
|
||||
/* Detach the task. */
|
||||
*out_task_id = task_id;
|
||||
*out_handle = m_rpc_client->DetachReadableHandle(task_id);
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result HtcsService::ReceiveSmallResults(s32 *out_err, s64 *out_size, char *buffer, s64 buffer_size, u32 task_id, s32 desc) {
|
||||
AMS_UNUSED(desc);
|
||||
|
||||
/* Continue the task. */
|
||||
m_rpc_client->ReceiveContinue<rpc::ReceiveSmallTask>(task_id, buffer, buffer_size);
|
||||
|
||||
/* Finish the task. */
|
||||
htcs::SocketError err;
|
||||
R_TRY(m_rpc_client->End<rpc::ReceiveSmallTask>(task_id, std::addressof(err), out_size));
|
||||
|
||||
/* Set output. */
|
||||
*out_err = err;
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result HtcsService::SendSmallStart(u32 *out_task_id, os::NativeHandle *out_handle, s32 desc, s64 size, s32 flags) {
|
||||
/* Begin the task. */
|
||||
u32 task_id{};
|
||||
R_TRY(m_rpc_client->Begin<rpc::SendSmallTask>(std::addressof(task_id), desc, size, static_cast<htcs::MessageFlag>(flags)));
|
||||
|
||||
/* Detach the task. */
|
||||
*out_task_id = task_id;
|
||||
*out_handle = m_rpc_client->DetachReadableHandle(task_id);
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result HtcsService::SendSmallContinue(s64 *out_size, const char *buffer, s64 buffer_size, u32 task_id, s32 desc) {
|
||||
/* Verify the task. */
|
||||
R_TRY(m_rpc_client->VerifyTaskIdWithHandle<rpc::SendSmallTask>(task_id, desc));
|
||||
|
||||
/* Continue the task. */
|
||||
R_TRY(m_rpc_client->SendContinue<rpc::SendSmallTask>(task_id, buffer, buffer_size));
|
||||
|
||||
/* Set output. */
|
||||
*out_size = buffer_size;
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result HtcsService::SendSmallResults(s32 *out_err, s64 *out_size, u32 task_id, s32 desc) {
|
||||
AMS_UNUSED(desc);
|
||||
|
||||
/* Finish the task. */
|
||||
htcs::SocketError err;
|
||||
R_TRY(m_rpc_client->End<rpc::SendSmallTask>(task_id, std::addressof(err), out_size));
|
||||
|
||||
/* Set output. */
|
||||
*out_err = err;
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result HtcsService::SendStart(u32 *out_task_id, os::NativeHandle *out_handle, s32 desc, s64 size, s32 flags) {
|
||||
/* Begin the task. */
|
||||
u32 task_id{};
|
||||
R_TRY(m_rpc_client->Begin<rpc::SendTask>(std::addressof(task_id), desc, size, static_cast<htcs::MessageFlag>(flags)));
|
||||
|
||||
/* Detach the task. */
|
||||
*out_task_id = task_id;
|
||||
*out_handle = m_rpc_client->DetachReadableHandle(task_id);
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result HtcsService::SendContinue(s64 *out_size, const char *buffer, s64 buffer_size, u32 task_id, s32 desc) {
|
||||
/* Verify the task. */
|
||||
R_TRY(m_rpc_client->VerifyTaskIdWithHandle<rpc::SendTask>(task_id, desc));
|
||||
|
||||
/* Wait for the task to notify. */
|
||||
m_rpc_client->WaitNotification<rpc::SendTask>(task_id);
|
||||
|
||||
/* Check the task status. */
|
||||
R_UNLESS(!m_rpc_client->IsCompleted<rpc::SendTask>(task_id), htcs::ResultCompleted());
|
||||
R_UNLESS(!m_rpc_client->IsCancelled<rpc::SendTask>(task_id), htcs::ResultCancelled());
|
||||
|
||||
/* Send the data. */
|
||||
if (buffer_size > 0) {
|
||||
R_TRY(m_data_channel_manager->Send(buffer, buffer_size, task_id));
|
||||
}
|
||||
|
||||
/* Set output. */
|
||||
*out_size = buffer_size;
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result HtcsService::SendResults(s32 *out_err, s64 *out_size, u32 task_id, s32 desc) {
|
||||
/* Verify the task. */
|
||||
R_TRY(m_rpc_client->VerifyTaskIdWithHandle<rpc::SendTask>(task_id, desc));
|
||||
|
||||
/* Finish the task. */
|
||||
htcs::SocketError err;
|
||||
R_TRY(m_rpc_client->End<rpc::SendTask>(task_id, std::addressof(err), out_size));
|
||||
|
||||
/* Set output. */
|
||||
*out_err = err;
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result HtcsService::ReceiveStart(u32 *out_task_id, os::NativeHandle *out_handle, s64 size, s32 desc, s32 flags) {
|
||||
/* Begin the task. */
|
||||
u32 task_id{};
|
||||
R_TRY(m_rpc_client->Begin<rpc::ReceiveTask>(std::addressof(task_id), desc, size, static_cast<htcs::MessageFlag>(flags)));
|
||||
|
||||
/* Detach the task. */
|
||||
*out_task_id = task_id;
|
||||
*out_handle = m_rpc_client->DetachReadableHandle(task_id);
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result HtcsService::ReceiveResults(s32 *out_err, s64 *out_size, char *buffer, s64 buffer_size, u32 task_id, s32 desc) {
|
||||
/* Verify the task. */
|
||||
R_TRY(m_rpc_client->VerifyTaskIdWithHandle<rpc::ReceiveTask>(task_id, desc));
|
||||
|
||||
/* Get the result. */
|
||||
htcs::SocketError err{};
|
||||
s64 recv_size{};
|
||||
const Result result = m_rpc_client->GetResult<rpc::ReceiveTask>(task_id, std::addressof(err), std::addressof(recv_size));
|
||||
if (R_FAILED(result) || err != HTCS_ENONE) {
|
||||
/* Finish the task. */
|
||||
R_TRY(m_rpc_client->End<rpc::ReceiveTask>(task_id, std::addressof(err), out_size));
|
||||
|
||||
/* Set output. */
|
||||
*out_err = err;
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
/* Check the size. */
|
||||
R_UNLESS(recv_size <= buffer_size, htcs::ResultInvalidArgument());
|
||||
|
||||
/* Perform remaining processing. */
|
||||
if (recv_size > 0) {
|
||||
/* Receive data. */
|
||||
const Result recv_result = m_data_channel_manager->Receive(buffer, recv_size, task_id);
|
||||
|
||||
/* Finish the task. */
|
||||
R_TRY(m_rpc_client->End<rpc::ReceiveTask>(task_id, std::addressof(err), out_size));
|
||||
|
||||
/* Check that our receive succeeded. */
|
||||
R_TRY(recv_result);
|
||||
} else {
|
||||
/* Finish the task. */
|
||||
R_TRY(m_rpc_client->End<rpc::ReceiveTask>(task_id, std::addressof(err), out_size));
|
||||
}
|
||||
|
||||
/* Set output. */
|
||||
*out_err = err;
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result HtcsService::SelectStart(u32 *out_task_id, os::NativeHandle *out_handle, Span<const int> read_handles, Span<const int> write_handles, Span<const int> exception_handles, s64 tv_sec, s64 tv_usec) {
|
||||
/* Begin the task. */
|
||||
u32 task_id{};
|
||||
R_TRY(m_rpc_client->Begin<rpc::SelectTask>(std::addressof(task_id), read_handles, write_handles, exception_handles, tv_sec, tv_usec));
|
||||
|
||||
/* Detach the task. */
|
||||
*out_task_id = task_id;
|
||||
*out_handle = m_rpc_client->DetachReadableHandle(task_id);
|
||||
|
||||
/* Check that the task isn't cancelled. */
|
||||
R_UNLESS(!m_rpc_client->IsCancelled<rpc::SelectTask>(task_id), htcs::ResultCancelled());
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result HtcsService::SelectEnd(s32 *out_err, bool *out_empty, Span<int> read_handles, Span<int> write_handles, Span<int> exception_handles, u32 task_id) {
|
||||
/* Finish the task. */
|
||||
htcs::SocketError err;
|
||||
bool empty;
|
||||
R_TRY(m_rpc_client->End<rpc::SelectTask>(task_id, std::addressof(err), std::addressof(empty), read_handles, write_handles, exception_handles));
|
||||
|
||||
/* Set output. */
|
||||
*out_err = err;
|
||||
*out_empty = empty;
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,67 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 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/>.
|
||||
*/
|
||||
#pragma once
|
||||
#include <stratosphere.hpp>
|
||||
#include "../../htc/server/driver/htc_i_driver.hpp"
|
||||
#include "../../htc/server/rpc/htc_rpc_client.hpp"
|
||||
#include "rpc/htcs_data_channel_manager.hpp"
|
||||
|
||||
namespace ams::htcs::impl {
|
||||
|
||||
class HtcsService {
|
||||
private:
|
||||
mem::StandardAllocator *m_allocator;
|
||||
htc::server::driver::IDriver *m_driver;
|
||||
htc::server::rpc::RpcClient *m_rpc_client;
|
||||
rpc::DataChannelManager *m_data_channel_manager;
|
||||
public:
|
||||
HtcsService(mem::StandardAllocator *allocator, htc::server::driver::IDriver *drv, htc::server::rpc::RpcClient *rc, rpc::DataChannelManager *dcm)
|
||||
: m_allocator(allocator), m_driver(drv), m_rpc_client(rc), m_data_channel_manager(dcm) { /* ... */ }
|
||||
public:
|
||||
Result CreateSocket(s32 *out_err, s32 *out_desc, bool enable_disconnection_emulation);
|
||||
Result DestroySocket(s32 desc);
|
||||
Result Connect(s32 *out_err, s32 desc, const SockAddrHtcs &address);
|
||||
Result Bind(s32 *out_err, s32 desc, const SockAddrHtcs &address);
|
||||
Result Listen(s32 *out_err, s32 desc, s32 backlog_count);
|
||||
Result Receive(s32 *out_err, s64 *out_size, char *buffer, s64 size, s32 desc, s32 flags);
|
||||
Result Send(s32 *out_err, s64 *out_size, const char *buffer, s64 size, s32 desc, s32 flags);
|
||||
Result Shutdown(s32 *out_err, s32 desc, s32 how);
|
||||
Result Fcntl(s32 *out_err, s32 *out_res, s32 desc, s32 command, s32 value);
|
||||
|
||||
Result AcceptStart(u32 *out_task_id, os::NativeHandle *out_handle, s32 desc);
|
||||
Result AcceptResults(s32 *out_err, s32 *out_desc, SockAddrHtcs *out_address, u32 task_id, s32 desc);
|
||||
|
||||
Result ReceiveSmallStart(u32 *out_task_id, os::NativeHandle *out_handle, s64 size, s32 desc, s32 flags);
|
||||
Result ReceiveSmallResults(s32 *out_err, s64 *out_size, char *buffer, s64 buffer_size, u32 task_id, s32 desc);
|
||||
|
||||
Result SendSmallStart(u32 *out_task_id, os::NativeHandle *out_handle, s32 desc, s64 size, s32 flags);
|
||||
Result SendSmallContinue(s64 *out_size, const char *buffer, s64 buffer_size, u32 task_id, s32 desc);
|
||||
Result SendSmallResults(s32 *out_err, s64 *out_size, u32 task_id, s32 desc);
|
||||
|
||||
Result SendStart(u32 *out_task_id, os::NativeHandle *out_handle, s32 desc, s64 size, s32 flags);
|
||||
Result SendContinue(s64 *out_size, const char *buffer, s64 buffer_size, u32 task_id, s32 desc);
|
||||
Result SendResults(s32 *out_err, s64 *out_size, u32 task_id, s32 desc);
|
||||
|
||||
Result ReceiveStart(u32 *out_task_id, os::NativeHandle *out_handle, s64 size, s32 desc, s32 flags);
|
||||
Result ReceiveResults(s32 *out_err, s64 *out_size, char *buffer, s64 buffer_size, u32 task_id, s32 desc);
|
||||
|
||||
Result SelectStart(u32 *out_task_id, os::NativeHandle *out_handle, Span<const int> read_handles, Span<const int> write_handles, Span<const int> exception_handles, s64 tv_sec, s64 tv_usec);
|
||||
Result SelectEnd(s32 *out_err, bool *out_empty, Span<int> read_handles, Span<int> write_handles, Span<int> exception_handles, u32 task_id);
|
||||
private:
|
||||
void WaitTask(u32 task_id);
|
||||
};
|
||||
|
||||
}
|
||||
@@ -1,44 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 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 "htcs_util.hpp"
|
||||
|
||||
namespace ams::htcs::impl {
|
||||
|
||||
s32 ConvertResultToErrorCode(const Result result) {
|
||||
/* Convert success. */
|
||||
if (R_SUCCEEDED(result)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
R_TRY_CATCH(result) {
|
||||
R_CATCH(htclow::ResultNonBlockingReceiveFailed) { return HTCS_EWOULDBLOCK; }
|
||||
R_CATCH(htcs::ResultInvalidHandle) { return HTCS_EBADF; }
|
||||
R_CATCH(htc::ResultUnknown2001) { return HTCS_EINVAL; }
|
||||
R_CATCH(htc::ResultUnknown2101) { return HTCS_EMFILE; }
|
||||
R_CATCH(htc::ResultTaskCancelled) { return HTCS_EINTR; }
|
||||
R_CATCH(htc::ResultInvalidTaskId) { return HTCS_EINTR; }
|
||||
R_CATCH(htc::ResultCancelled) { return HTCS_EINTR; }
|
||||
R_CATCH(htc::ResultTaskQueueNotAvailable) { return HTCS_ENETDOWN; }
|
||||
R_CATCH(htclow::ResultConnectionFailure) { return HTCS_ENETDOWN; }
|
||||
R_CATCH(htclow::ResultChannelNotExist) { return HTCS_ENOTCONN; }
|
||||
R_CATCH_ALL() { return HTCS_EUNKNOWN; }
|
||||
} R_END_TRY_CATCH_WITH_ABORT_UNLESS;
|
||||
|
||||
__builtin_unreachable();
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,36 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 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/>.
|
||||
*/
|
||||
#pragma once
|
||||
#include <stratosphere.hpp>
|
||||
|
||||
namespace ams::htcs::impl {
|
||||
|
||||
s32 ConvertResultToErrorCode(const Result result);
|
||||
|
||||
constexpr bool IsValidName(const char *name) {
|
||||
static_assert(PeerNameBufferLength == PortNameBufferLength);
|
||||
return util::Strnlen(name, PeerNameBufferLength) < PeerNameBufferLength;
|
||||
}
|
||||
|
||||
constexpr bool IsValidName(const HtcsPeerName &name) {
|
||||
return IsValidName(name.name);
|
||||
}
|
||||
|
||||
constexpr bool IsValidName(const HtcsPortName &name) {
|
||||
return IsValidName(name.name);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,98 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 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 "htcs_rpc_tasks.hpp"
|
||||
#include "htcs_data_channel_manager.hpp"
|
||||
#include "../../../htclow/htclow_channel.hpp"
|
||||
|
||||
namespace ams::htcs::impl::rpc {
|
||||
|
||||
Result DataChannelManager::Receive(void *buffer, s64 buffer_size, u32 task_id) {
|
||||
/* Check that the buffer size is allowable. */
|
||||
R_UNLESS(util::IsIntValueRepresentable<size_t>(buffer_size), htcs::ResultInvalidSize());
|
||||
|
||||
/* Create an htclow channel. */
|
||||
htclow::Channel channel(m_htclow_manager);
|
||||
|
||||
/* Open the channel. */
|
||||
R_ABORT_UNLESS(channel.Open(std::addressof(m_module), GetReceiveDataChannelId(task_id)));
|
||||
|
||||
/* Ensure that we close the channel, when we're done. */
|
||||
ON_SCOPE_EXIT { channel.Close(); };
|
||||
|
||||
/* Set the channel config. */
|
||||
constexpr htclow::ChannelConfig BulkReceiveConfig = {
|
||||
.flow_control_enabled = false,
|
||||
.handshake_enabled = false,
|
||||
.max_packet_size = 0x3E000,
|
||||
};
|
||||
channel.SetConfig(BulkReceiveConfig);
|
||||
|
||||
/* Set the receive buffer. */
|
||||
channel.SetReceiveBuffer(buffer, buffer_size);
|
||||
|
||||
/* Connect the channel. */
|
||||
R_TRY(channel.Connect());
|
||||
|
||||
/* Ensure that we clean up when we're done. */
|
||||
ON_SCOPE_EXIT { channel.Shutdown(); };
|
||||
|
||||
/* Notify the receive task. */
|
||||
R_TRY(m_rpc_client->Notify<ReceiveTask>(task_id));
|
||||
|
||||
/* Wait to receive the data. */
|
||||
R_TRY(channel.WaitReceive(buffer_size));
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result DataChannelManager::Send(const void *buffer, s64 buffer_size, u32 task_id) {
|
||||
/* Check that the buffer size is allowable. */
|
||||
R_UNLESS(util::IsIntValueRepresentable<size_t>(buffer_size), htcs::ResultInvalidSize());
|
||||
|
||||
/* Create an htclow channel. */
|
||||
htclow::Channel channel(m_htclow_manager);
|
||||
|
||||
/* Open the channel. */
|
||||
R_ABORT_UNLESS(channel.Open(std::addressof(m_module), GetSendDataChannelId(task_id)));
|
||||
|
||||
/* Ensure that we close the channel, when we're done. */
|
||||
ON_SCOPE_EXIT { channel.Close(); };
|
||||
|
||||
/* Set the channel config. */
|
||||
constexpr htclow::ChannelConfig BulkSendConfig = {
|
||||
.flow_control_enabled = false,
|
||||
.handshake_enabled = false,
|
||||
.max_packet_size = 0x3E000,
|
||||
};
|
||||
channel.SetConfig(BulkSendConfig);
|
||||
|
||||
/* Set the send buffer. */
|
||||
channel.SetSendBufferWithData(buffer, buffer_size);
|
||||
|
||||
/* Connect the channel. */
|
||||
R_TRY(channel.Connect());
|
||||
|
||||
/* Ensure that we clean up when we're done. */
|
||||
ON_SCOPE_EXIT { channel.Shutdown(); };
|
||||
|
||||
/* Wait to send the data. */
|
||||
R_TRY(channel.Flush());
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,35 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 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/>.
|
||||
*/
|
||||
#pragma once
|
||||
#include <stratosphere.hpp>
|
||||
#include "../../../htclow/htclow_manager.hpp"
|
||||
#include "../../../htc/server/rpc/htc_rpc_client.hpp"
|
||||
|
||||
namespace ams::htcs::impl::rpc {
|
||||
|
||||
class DataChannelManager {
|
||||
private:
|
||||
htc::server::rpc::RpcClient* m_rpc_client;
|
||||
htclow::HtclowManager *m_htclow_manager;
|
||||
htclow::Module m_module;
|
||||
public:
|
||||
DataChannelManager(htc::server::rpc::RpcClient *client, htclow::HtclowManager *htclow_manager) : m_rpc_client(client), m_htclow_manager(htclow_manager), m_module(htclow::ModuleId::Htcs) { /* ... */ }
|
||||
public:
|
||||
Result Receive(void *buffer, s64 buffer_size, u32 task_id);
|
||||
Result Send(const void *buffer, s64 buffer_size, u32 task_id);
|
||||
};
|
||||
|
||||
}
|
||||
@@ -1,89 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 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 "htcs_rpc_tasks.hpp"
|
||||
|
||||
namespace ams::htcs::impl::rpc {
|
||||
|
||||
Result AcceptTask::SetArguments(s32 server_handle) {
|
||||
/* Check that we're valid. */
|
||||
R_UNLESS(this->IsValid(), htcs::ResultInvalidTask());
|
||||
|
||||
/* Set our arguments. */
|
||||
m_server_handle = server_handle;
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
void AcceptTask::Complete(htcs::SocketError err, s32 desc) {
|
||||
/* Set our results. */
|
||||
m_err = err;
|
||||
m_desc = desc;
|
||||
|
||||
/* Complete. */
|
||||
HtcsSignalingTask::Complete();
|
||||
}
|
||||
|
||||
Result AcceptTask::GetResult(htcs::SocketError *out_err, s32 *out_desc, s32 server_handle) const {
|
||||
/* Check the server handle. */
|
||||
R_UNLESS(m_server_handle == server_handle, htcs::ResultInvalidServerHandle());
|
||||
|
||||
/* Sanity check our state. */
|
||||
AMS_ASSERT(this->GetTaskState() == htc::server::rpc::RpcTaskState::Completed);
|
||||
|
||||
/* Set the output. */
|
||||
*out_err = m_err;
|
||||
*out_desc = m_desc;
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result AcceptTask::ProcessResponse(const char *data, size_t size) {
|
||||
AMS_UNUSED(size);
|
||||
|
||||
/* Convert the input to a packet. */
|
||||
auto *packet = reinterpret_cast<const HtcsRpcPacket *>(data);
|
||||
|
||||
/* Complete the task. */
|
||||
this->Complete(static_cast<htcs::SocketError>(packet->params[0]), packet->params[1]);
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result AcceptTask::CreateRequest(size_t *out, char *data, size_t size, u32 task_id) {
|
||||
AMS_UNUSED(size);
|
||||
|
||||
/* Create the packet. */
|
||||
auto *packet = reinterpret_cast<HtcsRpcPacket *>(data);
|
||||
*packet = {
|
||||
.protocol = HtcsProtocol,
|
||||
.version = this->GetVersion(),
|
||||
.category = HtcsPacketCategory::Request,
|
||||
.type = HtcsPacketType::Accept,
|
||||
.body_size = 0,
|
||||
.task_id = task_id,
|
||||
.params = {
|
||||
m_server_handle,
|
||||
},
|
||||
};
|
||||
|
||||
/* Set the output size. */
|
||||
*out = sizeof(*packet);
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,85 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 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 "htcs_rpc_tasks.hpp"
|
||||
|
||||
namespace ams::htcs::impl::rpc {
|
||||
|
||||
Result BindTask::SetArguments(s32 handle, const HtcsPeerName &peer_name, const HtcsPortName &port_name) {
|
||||
/* Set our arguments. */
|
||||
m_handle = handle;
|
||||
m_peer_name = peer_name;
|
||||
m_port_name = port_name;
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
void BindTask::Complete(htcs::SocketError err) {
|
||||
/* Set our results. */
|
||||
m_err = err;
|
||||
|
||||
/* Complete. */
|
||||
HtcsTask::Complete();
|
||||
}
|
||||
|
||||
Result BindTask::GetResult(htcs::SocketError *out_err) const {
|
||||
/* Sanity check our state. */
|
||||
AMS_ASSERT(this->GetTaskState() == htc::server::rpc::RpcTaskState::Completed);
|
||||
|
||||
/* Set the output. */
|
||||
*out_err = m_err;
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result BindTask::ProcessResponse(const char *data, size_t size) {
|
||||
AMS_UNUSED(size);
|
||||
|
||||
/* Convert the input to a packet. */
|
||||
auto *packet = reinterpret_cast<const HtcsRpcPacket *>(data);
|
||||
|
||||
/* Complete the task. */
|
||||
this->Complete(static_cast<htcs::SocketError>(packet->params[0]));
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result BindTask::CreateRequest(size_t *out, char *data, size_t size, u32 task_id) {
|
||||
AMS_UNUSED(size);
|
||||
|
||||
/* Create the packet. */
|
||||
auto *packet = reinterpret_cast<HtcsRpcPacket *>(data);
|
||||
*packet = {
|
||||
.protocol = HtcsProtocol,
|
||||
.version = this->GetVersion(),
|
||||
.category = HtcsPacketCategory::Request,
|
||||
.type = HtcsPacketType::Bind,
|
||||
.body_size = sizeof(m_peer_name) + sizeof(m_port_name),
|
||||
.task_id = task_id,
|
||||
.params = {
|
||||
m_handle,
|
||||
},
|
||||
};
|
||||
std::memcpy(packet->data + 0, std::addressof(m_peer_name), sizeof(m_peer_name));
|
||||
std::memcpy(packet->data + sizeof(m_peer_name), std::addressof(m_port_name), sizeof(m_port_name));
|
||||
|
||||
/* Set the output size. */
|
||||
*out = sizeof(*packet) + sizeof(m_peer_name) + sizeof(m_port_name);
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,81 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 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 "htcs_rpc_tasks.hpp"
|
||||
|
||||
namespace ams::htcs::impl::rpc {
|
||||
|
||||
Result CloseTask::SetArguments(s32 handle) {
|
||||
/* Set our arguments. */
|
||||
m_handle = handle;
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
void CloseTask::Complete(htcs::SocketError err) {
|
||||
/* Set our results. */
|
||||
m_err = err;
|
||||
|
||||
/* Complete. */
|
||||
HtcsTask::Complete();
|
||||
}
|
||||
|
||||
Result CloseTask::GetResult(htcs::SocketError *out_err) const {
|
||||
/* Sanity check our state. */
|
||||
AMS_ASSERT(this->GetTaskState() == htc::server::rpc::RpcTaskState::Completed);
|
||||
|
||||
/* Set the output. */
|
||||
*out_err = m_err;
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result CloseTask::ProcessResponse(const char *data, size_t size) {
|
||||
AMS_UNUSED(size);
|
||||
|
||||
/* Convert the input to a packet. */
|
||||
auto *packet = reinterpret_cast<const HtcsRpcPacket *>(data);
|
||||
|
||||
/* Complete the task. */
|
||||
this->Complete(static_cast<htcs::SocketError>(packet->params[0]));
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result CloseTask::CreateRequest(size_t *out, char *data, size_t size, u32 task_id) {
|
||||
AMS_UNUSED(size);
|
||||
|
||||
/* Create the packet. */
|
||||
auto *packet = reinterpret_cast<HtcsRpcPacket *>(data);
|
||||
*packet = {
|
||||
.protocol = HtcsProtocol,
|
||||
.version = this->GetVersion(),
|
||||
.category = HtcsPacketCategory::Request,
|
||||
.type = HtcsPacketType::Close,
|
||||
.body_size = 0,
|
||||
.task_id = task_id,
|
||||
.params = {
|
||||
m_handle,
|
||||
},
|
||||
};
|
||||
|
||||
/* Set the output size. */
|
||||
*out = sizeof(*packet);
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,85 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 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 "htcs_rpc_tasks.hpp"
|
||||
|
||||
namespace ams::htcs::impl::rpc {
|
||||
|
||||
Result ConnectTask::SetArguments(s32 handle, const HtcsPeerName &peer_name, const HtcsPortName &port_name) {
|
||||
/* Set our arguments. */
|
||||
m_handle = handle;
|
||||
m_peer_name = peer_name;
|
||||
m_port_name = port_name;
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
void ConnectTask::Complete(htcs::SocketError err) {
|
||||
/* Set our results. */
|
||||
m_err = err;
|
||||
|
||||
/* Complete. */
|
||||
HtcsTask::Complete();
|
||||
}
|
||||
|
||||
Result ConnectTask::GetResult(htcs::SocketError *out_err) const {
|
||||
/* Sanity check our state. */
|
||||
AMS_ASSERT(this->GetTaskState() == htc::server::rpc::RpcTaskState::Completed);
|
||||
|
||||
/* Set the output. */
|
||||
*out_err = m_err;
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result ConnectTask::ProcessResponse(const char *data, size_t size) {
|
||||
AMS_UNUSED(size);
|
||||
|
||||
/* Convert the input to a packet. */
|
||||
auto *packet = reinterpret_cast<const HtcsRpcPacket *>(data);
|
||||
|
||||
/* Complete the task. */
|
||||
this->Complete(static_cast<htcs::SocketError>(packet->params[0]));
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result ConnectTask::CreateRequest(size_t *out, char *data, size_t size, u32 task_id) {
|
||||
AMS_UNUSED(size);
|
||||
|
||||
/* Create the packet. */
|
||||
auto *packet = reinterpret_cast<HtcsRpcPacket *>(data);
|
||||
*packet = {
|
||||
.protocol = HtcsProtocol,
|
||||
.version = this->GetVersion(),
|
||||
.category = HtcsPacketCategory::Request,
|
||||
.type = HtcsPacketType::Connect,
|
||||
.body_size = sizeof(m_peer_name) + sizeof(m_port_name),
|
||||
.task_id = task_id,
|
||||
.params = {
|
||||
m_handle,
|
||||
},
|
||||
};
|
||||
std::memcpy(packet->data + 0, std::addressof(m_peer_name), sizeof(m_peer_name));
|
||||
std::memcpy(packet->data + sizeof(m_peer_name), std::addressof(m_port_name), sizeof(m_port_name));
|
||||
|
||||
/* Set the output size. */
|
||||
*out = sizeof(*packet) + sizeof(m_peer_name) + sizeof(m_port_name);
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,87 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 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 "htcs_rpc_tasks.hpp"
|
||||
|
||||
namespace ams::htcs::impl::rpc {
|
||||
|
||||
Result FcntlTask::SetArguments(s32 handle, s32 command, s32 value) {
|
||||
/* Set our arguments. */
|
||||
m_handle = handle;
|
||||
m_command = command;
|
||||
m_value = value;
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
void FcntlTask::Complete(htcs::SocketError err, s32 res) {
|
||||
/* Set our results. */
|
||||
m_err = err;
|
||||
m_res = res;
|
||||
|
||||
/* Complete. */
|
||||
HtcsTask::Complete();
|
||||
}
|
||||
|
||||
Result FcntlTask::GetResult(htcs::SocketError *out_err, s32 *out_res) const {
|
||||
/* Sanity check our state. */
|
||||
AMS_ASSERT(this->GetTaskState() == htc::server::rpc::RpcTaskState::Completed);
|
||||
|
||||
/* Set the output. */
|
||||
*out_err = m_err;
|
||||
*out_res = m_res;
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result FcntlTask::ProcessResponse(const char *data, size_t size) {
|
||||
AMS_UNUSED(size);
|
||||
|
||||
/* Convert the input to a packet. */
|
||||
auto *packet = reinterpret_cast<const HtcsRpcPacket *>(data);
|
||||
|
||||
/* Complete the task. */
|
||||
this->Complete(static_cast<htcs::SocketError>(packet->params[0]), packet->params[1]);
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result FcntlTask::CreateRequest(size_t *out, char *data, size_t size, u32 task_id) {
|
||||
AMS_UNUSED(size);
|
||||
|
||||
/* Create the packet. */
|
||||
auto *packet = reinterpret_cast<HtcsRpcPacket *>(data);
|
||||
*packet = {
|
||||
.protocol = HtcsProtocol,
|
||||
.version = this->GetVersion(),
|
||||
.category = HtcsPacketCategory::Request,
|
||||
.type = HtcsPacketType::Fcntl,
|
||||
.body_size = 0,
|
||||
.task_id = task_id,
|
||||
.params = {
|
||||
m_handle,
|
||||
m_command,
|
||||
m_value,
|
||||
},
|
||||
};
|
||||
|
||||
/* Set the output size. */
|
||||
*out = sizeof(*packet);
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,83 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 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 "htcs_rpc_tasks.hpp"
|
||||
|
||||
namespace ams::htcs::impl::rpc {
|
||||
|
||||
Result ListenTask::SetArguments(s32 handle, s32 backlog) {
|
||||
/* Set our arguments. */
|
||||
m_handle = handle;
|
||||
m_backlog = backlog;
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
void ListenTask::Complete(htcs::SocketError err) {
|
||||
/* Set our results. */
|
||||
m_err = err;
|
||||
|
||||
/* Complete. */
|
||||
HtcsTask::Complete();
|
||||
}
|
||||
|
||||
Result ListenTask::GetResult(htcs::SocketError *out_err) const {
|
||||
/* Sanity check our state. */
|
||||
AMS_ASSERT(this->GetTaskState() == htc::server::rpc::RpcTaskState::Completed);
|
||||
|
||||
/* Set the output. */
|
||||
*out_err = m_err;
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result ListenTask::ProcessResponse(const char *data, size_t size) {
|
||||
AMS_UNUSED(size);
|
||||
|
||||
/* Convert the input to a packet. */
|
||||
auto *packet = reinterpret_cast<const HtcsRpcPacket *>(data);
|
||||
|
||||
/* Complete the task. */
|
||||
this->Complete(static_cast<htcs::SocketError>(packet->params[0]));
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result ListenTask::CreateRequest(size_t *out, char *data, size_t size, u32 task_id) {
|
||||
AMS_UNUSED(size);
|
||||
|
||||
/* Create the packet. */
|
||||
auto *packet = reinterpret_cast<HtcsRpcPacket *>(data);
|
||||
*packet = {
|
||||
.protocol = HtcsProtocol,
|
||||
.version = this->GetVersion(),
|
||||
.category = HtcsPacketCategory::Request,
|
||||
.type = HtcsPacketType::Listen,
|
||||
.body_size = 0,
|
||||
.task_id = task_id,
|
||||
.params = {
|
||||
m_handle,
|
||||
m_backlog,
|
||||
},
|
||||
};
|
||||
|
||||
/* Set the output size. */
|
||||
*out = sizeof(*packet);
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,97 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 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 "htcs_rpc_tasks.hpp"
|
||||
|
||||
namespace ams::htcs::impl::rpc {
|
||||
|
||||
Result ReceiveSmallTask::SetArguments(s32 handle, s64 size, htcs::MessageFlag flags) {
|
||||
/* Check that we're valid. */
|
||||
R_UNLESS(this->IsValid(), htcs::ResultInvalidTask());
|
||||
|
||||
/* Set our arguments. */
|
||||
m_handle = handle;
|
||||
m_size = size;
|
||||
m_flags = flags;
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
void ReceiveSmallTask::Complete(htcs::SocketError err, s64 size) {
|
||||
/* Set our results. */
|
||||
m_err = err;
|
||||
m_result_size = size;
|
||||
|
||||
/* Complete. */
|
||||
HtcsSignalingTask::Complete();
|
||||
}
|
||||
|
||||
Result ReceiveSmallTask::GetResult(htcs::SocketError *out_err, s64 *out_size) const {
|
||||
/* Sanity check our state. */
|
||||
AMS_ASSERT(this->GetTaskState() == htc::server::rpc::RpcTaskState::Completed);
|
||||
|
||||
/* Set the output. */
|
||||
*out_err = m_err;
|
||||
*out_size = m_result_size;
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result ReceiveSmallTask::ProcessResponse(const char *data, size_t size) {
|
||||
AMS_UNUSED(size);
|
||||
|
||||
/* Convert the input to a packet. */
|
||||
auto *packet = reinterpret_cast<const HtcsRpcPacket *>(data);
|
||||
|
||||
/* Copy the data to our buffer. */
|
||||
std::memcpy(m_buffer, packet->data, packet->body_size);
|
||||
|
||||
/* Complete the task. */
|
||||
this->Complete(static_cast<htcs::SocketError>(packet->params[0]), packet->body_size);
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result ReceiveSmallTask::CreateRequest(size_t *out, char *data, size_t size, u32 task_id) {
|
||||
AMS_UNUSED(size);
|
||||
|
||||
/* Create the packet. */
|
||||
auto *packet = reinterpret_cast<HtcsRpcPacket *>(data);
|
||||
*packet = {
|
||||
.protocol = HtcsProtocol,
|
||||
.version = this->GetVersion(),
|
||||
.category = HtcsPacketCategory::Request,
|
||||
.type = HtcsPacketType::Receive,
|
||||
.body_size = 0,
|
||||
.task_id = task_id,
|
||||
.params = {
|
||||
m_handle,
|
||||
m_size,
|
||||
static_cast<s64>(m_flags),
|
||||
},
|
||||
};
|
||||
|
||||
/* Set the output size. */
|
||||
*out = sizeof(*packet);
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
bool ReceiveSmallTask::IsReceiveBufferRequired() {
|
||||
return true;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,114 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 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 "htcs_rpc_tasks.hpp"
|
||||
|
||||
namespace ams::htcs::impl::rpc {
|
||||
|
||||
Result ReceiveTask::SetArguments(s32 handle, s64 size, htcs::MessageFlag flags) {
|
||||
/* Check that we're valid. */
|
||||
R_UNLESS(this->IsValid(), htcs::ResultInvalidTask());
|
||||
|
||||
/* Set our arguments. */
|
||||
m_handle = handle;
|
||||
m_size = size;
|
||||
m_flags = flags;
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
void ReceiveTask::Complete(htcs::SocketError err, s64 size) {
|
||||
/* Set our results. */
|
||||
m_err = err;
|
||||
m_result_size = size;
|
||||
|
||||
/* Complete. */
|
||||
HtcsSignalingTask::Complete();
|
||||
}
|
||||
|
||||
Result ReceiveTask::GetResult(htcs::SocketError *out_err, s64 *out_size) const {
|
||||
/* Sanity check our state. */
|
||||
AMS_ASSERT(this->GetTaskState() == htc::server::rpc::RpcTaskState::Completed);
|
||||
|
||||
/* Set the output. */
|
||||
*out_err = m_err;
|
||||
*out_size = m_result_size;
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result ReceiveTask::ProcessResponse(const char *data, size_t size) {
|
||||
AMS_UNUSED(size);
|
||||
|
||||
/* Convert the input to a packet. */
|
||||
auto *packet = reinterpret_cast<const HtcsRpcPacket *>(data);
|
||||
|
||||
/* Complete the task. */
|
||||
this->Complete(static_cast<htcs::SocketError>(packet->params[0]), packet->params[1]);
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result ReceiveTask::CreateRequest(size_t *out, char *data, size_t size, u32 task_id) {
|
||||
AMS_UNUSED(size);
|
||||
|
||||
/* Create the packet. */
|
||||
auto *packet = reinterpret_cast<HtcsRpcPacket *>(data);
|
||||
*packet = {
|
||||
.protocol = HtcsProtocol,
|
||||
.version = this->GetVersion(),
|
||||
.category = HtcsPacketCategory::Request,
|
||||
.type = HtcsPacketType::ReceiveLarge,
|
||||
.body_size = 0,
|
||||
.task_id = task_id,
|
||||
.params = {
|
||||
m_handle,
|
||||
m_size,
|
||||
static_cast<s64>(m_flags),
|
||||
GetReceiveDataChannelId(task_id),
|
||||
},
|
||||
};
|
||||
|
||||
/* Set the output size. */
|
||||
*out = sizeof(*packet);
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result ReceiveTask::CreateNotification(size_t *out, char *data, size_t size, u32 task_id) {
|
||||
AMS_UNUSED(size);
|
||||
|
||||
/* Create the packet. */
|
||||
auto *packet = reinterpret_cast<HtcsRpcPacket *>(data);
|
||||
*packet = {
|
||||
.protocol = HtcsProtocol,
|
||||
.version = this->GetVersion(),
|
||||
.category = HtcsPacketCategory::Notification,
|
||||
.type = HtcsPacketType::ReceiveLarge,
|
||||
.body_size = 0,
|
||||
.task_id = task_id,
|
||||
.params = {
|
||||
/* ... */
|
||||
},
|
||||
};
|
||||
|
||||
/* Set the output size. */
|
||||
*out = sizeof(*packet);
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,155 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 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 "htcs_rpc_tasks.hpp"
|
||||
|
||||
namespace ams::htcs::impl::rpc {
|
||||
|
||||
Result SelectTask::SetArguments(Span<const int> read_handles, Span<const int> write_handles, Span<const int> exception_handles, s64 tv_sec, s64 tv_usec) {
|
||||
/* Check that we're valid. */
|
||||
R_UNLESS(this->IsValid(), htcs::ResultInvalidTask());
|
||||
|
||||
/* Sanity check the spans. */
|
||||
AMS_ASSERT(read_handles.size() < static_cast<size_t>(SocketCountMax));
|
||||
AMS_ASSERT(write_handles.size() < static_cast<size_t>(SocketCountMax));
|
||||
AMS_ASSERT(exception_handles.size() < static_cast<size_t>(SocketCountMax));
|
||||
|
||||
/* Set our arguments. */
|
||||
m_read_handle_count = static_cast<s32>(read_handles.size());
|
||||
m_write_handle_count = static_cast<s32>(write_handles.size());
|
||||
m_exception_handle_count = static_cast<s32>(exception_handles.size());
|
||||
m_tv_sec = tv_sec;
|
||||
m_tv_usec = tv_usec;
|
||||
|
||||
/* Copy the handles. */
|
||||
std::memcpy(m_handles, read_handles.data(), read_handles.size_bytes());
|
||||
std::memcpy(m_handles + m_read_handle_count, write_handles.data(), write_handles.size_bytes());
|
||||
std::memcpy(m_handles + m_read_handle_count + m_write_handle_count, exception_handles.data(), exception_handles.size_bytes());
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
void SelectTask::Complete(htcs::SocketError err, s32 read_handle_count, s32 write_handle_count, s32 exception_handle_count, const void *body, s64 body_size) {
|
||||
/* Sanity check the handle counts. */
|
||||
const auto handle_count = read_handle_count + write_handle_count + exception_handle_count;
|
||||
AMS_ASSERT(0 <= read_handle_count && read_handle_count < SocketCountMax);
|
||||
AMS_ASSERT(0 <= write_handle_count && write_handle_count < SocketCountMax);
|
||||
AMS_ASSERT(0 <= exception_handle_count && exception_handle_count < SocketCountMax);
|
||||
AMS_ASSERT(handle_count * static_cast<s64>(sizeof(s32)) == body_size);
|
||||
AMS_UNUSED(handle_count, body_size);
|
||||
|
||||
/* Set our results. */
|
||||
m_err = err;
|
||||
m_out_read_handle_count = read_handle_count;
|
||||
m_out_write_handle_count = write_handle_count;
|
||||
m_out_exception_handle_count = exception_handle_count;
|
||||
|
||||
/* Copy the handles. */
|
||||
std::memcpy(m_out_handles, static_cast<const s32 *>(body), sizeof(s32) * read_handle_count);
|
||||
std::memcpy(m_out_handles + read_handle_count, static_cast<const s32 *>(body) + read_handle_count, sizeof(s32) * write_handle_count);
|
||||
std::memcpy(m_out_handles + read_handle_count + write_handle_count, static_cast<const s32 *>(body) + read_handle_count + write_handle_count, sizeof(s32) * exception_handle_count);
|
||||
|
||||
/* Complete. */
|
||||
HtcsSignalingTask::Complete();
|
||||
}
|
||||
|
||||
Result SelectTask::GetResult(htcs::SocketError *out_err, bool *out_empty, Span<int> read_handles, Span<int> write_handles, Span<int> exception_handles) const {
|
||||
/* Set the output error. */
|
||||
*out_err = m_err;
|
||||
|
||||
/* Set the output empty value. */
|
||||
const bool empty = m_err == HTCS_ENONE && m_out_read_handle_count == 0 && m_out_write_handle_count == 0 && m_out_exception_handle_count == 0;
|
||||
*out_empty = empty;
|
||||
|
||||
/* Clear the output spans. */
|
||||
std::fill(read_handles.begin(), read_handles.end(), 0);
|
||||
std::fill(write_handles.begin(), write_handles.end(), 0);
|
||||
std::fill(exception_handles.begin(), exception_handles.end(), 0);
|
||||
|
||||
/* Copy the handles. */
|
||||
if (m_err == HTCS_ENONE && !empty) {
|
||||
const s32 * const out_read_start = m_out_handles;
|
||||
const s32 * const out_read_end = out_read_start + m_out_read_handle_count;
|
||||
const s32 * const out_write_start = out_read_end;
|
||||
const s32 * const out_write_end = out_write_start + m_out_write_handle_count;
|
||||
const s32 * const out_exception_start = out_write_end;
|
||||
const s32 * const out_exception_end = out_exception_start + m_out_exception_handle_count;
|
||||
std::copy(out_read_start, out_read_end, read_handles.begin());
|
||||
std::copy(out_write_start, out_write_end, write_handles.begin());
|
||||
std::copy(out_exception_start, out_exception_end, exception_handles.begin());
|
||||
} else {
|
||||
const s32 * const read_start = m_handles;
|
||||
const s32 * const read_end = read_start + m_read_handle_count;
|
||||
const s32 * const write_start = read_end;
|
||||
const s32 * const write_end = write_start + m_write_handle_count;
|
||||
const s32 * const exception_start = write_end;
|
||||
const s32 * const exception_end = exception_start + m_exception_handle_count;
|
||||
std::copy(read_start, read_end, read_handles.begin());
|
||||
std::copy(write_start, write_end, write_handles.begin());
|
||||
std::copy(exception_start, exception_end, exception_handles.begin());
|
||||
}
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result SelectTask::ProcessResponse(const char *data, size_t size) {
|
||||
AMS_UNUSED(size);
|
||||
|
||||
/* Convert the input to a packet. */
|
||||
auto *packet = reinterpret_cast<const HtcsRpcPacket *>(data);
|
||||
|
||||
/* Complete the task. */
|
||||
this->Complete(static_cast<htcs::SocketError>(packet->params[0]), packet->params[1], packet->params[2], packet->params[3], packet->data, size - sizeof(*packet));
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result SelectTask::CreateRequest(size_t *out, char *data, size_t size, u32 task_id) {
|
||||
AMS_UNUSED(size);
|
||||
|
||||
/* Determine the body size. */
|
||||
const auto handle_count = m_read_handle_count + m_write_handle_count + m_exception_handle_count;
|
||||
const s64 body_size = static_cast<s64>(handle_count * sizeof(s32));
|
||||
AMS_ASSERT(sizeof(HtcsRpcPacket) + body_size <= size);
|
||||
|
||||
/* Create the packet. */
|
||||
auto *packet = reinterpret_cast<HtcsRpcPacket *>(data);
|
||||
*packet = {
|
||||
.protocol = HtcsProtocol,
|
||||
.version = this->GetVersion(),
|
||||
.category = HtcsPacketCategory::Request,
|
||||
.type = HtcsPacketType::Select,
|
||||
.body_size = body_size,
|
||||
.task_id = task_id,
|
||||
.params = {
|
||||
m_read_handle_count,
|
||||
m_write_handle_count,
|
||||
m_exception_handle_count,
|
||||
m_tv_sec,
|
||||
m_tv_usec,
|
||||
},
|
||||
};
|
||||
|
||||
/* Set the packet body. */
|
||||
std::memcpy(packet->data, m_handles, body_size);
|
||||
|
||||
/* Set the output size. */
|
||||
*out = sizeof(*packet) + body_size;
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,137 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 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 "htcs_rpc_tasks.hpp"
|
||||
|
||||
namespace ams::htcs::impl::rpc {
|
||||
|
||||
void SendSmallTask::SetBuffer(const void *buffer, s64 buffer_size) {
|
||||
/* Sanity check the buffer size. */
|
||||
AMS_ASSERT(0 <= buffer_size && buffer_size <= static_cast<s64>(sizeof(m_buffer)));
|
||||
|
||||
/* Set our buffer. */
|
||||
if (buffer_size > 0) {
|
||||
std::memcpy(m_buffer, buffer, buffer_size);
|
||||
}
|
||||
m_buffer_size = buffer_size;
|
||||
}
|
||||
|
||||
void SendSmallTask::NotifyDataChannelReady() {
|
||||
/* Notify. */
|
||||
this->Notify();
|
||||
|
||||
/* Signal our ready event. */
|
||||
m_ready_event.Signal();
|
||||
}
|
||||
|
||||
void SendSmallTask::WaitNotification() {
|
||||
/* Wait on our ready event. */
|
||||
m_ready_event.Wait();
|
||||
}
|
||||
|
||||
Result SendSmallTask::SetArguments(s32 handle, s64 size, htcs::MessageFlag flags) {
|
||||
/* Check that we're valid. */
|
||||
R_UNLESS(this->IsValid(), htcs::ResultInvalidTask());
|
||||
|
||||
/* Set our arguments. */
|
||||
m_handle = handle;
|
||||
m_size = size;
|
||||
m_flags = flags;
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
void SendSmallTask::Complete(htcs::SocketError err, s64 size) {
|
||||
/* Set our results. */
|
||||
m_err = err;
|
||||
m_result_size = size;
|
||||
|
||||
/* Signal our ready event. */
|
||||
m_ready_event.Signal();
|
||||
|
||||
/* Complete. */
|
||||
HtcsSignalingTask::Complete();
|
||||
}
|
||||
|
||||
Result SendSmallTask::GetResult(htcs::SocketError *out_err, s64 *out_size) const {
|
||||
/* Sanity check our state. */
|
||||
AMS_ASSERT(this->GetTaskState() == htc::server::rpc::RpcTaskState::Completed);
|
||||
|
||||
/* Set the output. */
|
||||
*out_err = m_err;
|
||||
*out_size = m_result_size;
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
void SendSmallTask::Cancel(htc::server::rpc::RpcTaskCancelReason reason) {
|
||||
/* Cancel the task. */
|
||||
HtcsSignalingTask::Cancel(reason);
|
||||
|
||||
/* Signal our ready event. */
|
||||
m_ready_event.Signal();
|
||||
}
|
||||
|
||||
Result SendSmallTask::ProcessResponse(const char *data, size_t size) {
|
||||
AMS_UNUSED(size);
|
||||
|
||||
/* Convert the input to a packet. */
|
||||
auto *packet = reinterpret_cast<const HtcsRpcPacket *>(data);
|
||||
|
||||
/* Complete the task. */
|
||||
this->Complete(static_cast<htcs::SocketError>(packet->params[0]), this->GetSize());
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result SendSmallTask::CreateRequest(size_t *out, char *data, size_t size, u32 task_id) {
|
||||
AMS_UNUSED(size);
|
||||
|
||||
/* Sanity check our size. */
|
||||
AMS_ASSERT(sizeof(HtcsRpcPacket) + this->GetBufferSize() <= size);
|
||||
|
||||
/* Create the packet. */
|
||||
auto *packet = reinterpret_cast<HtcsRpcPacket *>(data);
|
||||
*packet = {
|
||||
.protocol = HtcsProtocol,
|
||||
.version = this->GetVersion(),
|
||||
.category = HtcsPacketCategory::Request,
|
||||
.type = HtcsPacketType::Send,
|
||||
.body_size = this->GetSize(),
|
||||
.task_id = task_id,
|
||||
.params = {
|
||||
m_handle,
|
||||
m_size,
|
||||
static_cast<s64>(m_flags),
|
||||
},
|
||||
};
|
||||
|
||||
/* Set the body. */
|
||||
if (this->GetSize() > 0) {
|
||||
std::memcpy(packet->data, this->GetBuffer(), this->GetSize());
|
||||
}
|
||||
|
||||
/* Set the output size. */
|
||||
*out = sizeof(*packet) + this->GetSize();
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
bool SendSmallTask::IsSendBufferRequired() {
|
||||
return this->GetSize() > 0;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,151 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 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 "htcs_rpc_tasks.hpp"
|
||||
|
||||
namespace ams::htcs::impl::rpc {
|
||||
|
||||
void SendTask::SetBuffer(const void *buffer, s64 buffer_size) {
|
||||
/* Set our buffer. */
|
||||
m_buffer = buffer;
|
||||
m_buffer_size = buffer_size;
|
||||
}
|
||||
|
||||
void SendTask::NotifyDataChannelReady() {
|
||||
/* Notify. */
|
||||
this->Notify();
|
||||
|
||||
/* Signal our ready event. */
|
||||
m_ready_event.Signal();
|
||||
}
|
||||
|
||||
void SendTask::WaitNotification() {
|
||||
/* Wait on our ready event. */
|
||||
m_ready_event.Wait();
|
||||
}
|
||||
|
||||
Result SendTask::SetArguments(s32 handle, s64 size, htcs::MessageFlag flags) {
|
||||
/* Check that we're valid. */
|
||||
R_UNLESS(this->IsValid(), htcs::ResultInvalidTask());
|
||||
|
||||
/* Set our arguments. */
|
||||
m_handle = handle;
|
||||
m_size = size;
|
||||
m_flags = flags;
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
void SendTask::Complete(htcs::SocketError err, s64 size) {
|
||||
/* Set our results. */
|
||||
m_err = err;
|
||||
m_result_size = size;
|
||||
|
||||
/* Signal our ready event. */
|
||||
m_ready_event.Signal();
|
||||
|
||||
/* Complete. */
|
||||
HtcsSignalingTask::Complete();
|
||||
}
|
||||
|
||||
Result SendTask::GetResult(htcs::SocketError *out_err, s64 *out_size) const {
|
||||
/* Sanity check our state. */
|
||||
AMS_ASSERT(this->GetTaskState() == htc::server::rpc::RpcTaskState::Completed);
|
||||
|
||||
/* Set the output. */
|
||||
*out_err = m_err;
|
||||
*out_size = m_result_size;
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
void SendTask::Cancel(htc::server::rpc::RpcTaskCancelReason reason) {
|
||||
/* Cancel the task. */
|
||||
HtcsSignalingTask::Cancel(reason);
|
||||
|
||||
/* Signal our ready event. */
|
||||
m_ready_event.Signal();
|
||||
}
|
||||
|
||||
Result SendTask::ProcessResponse(const char *data, size_t size) {
|
||||
AMS_UNUSED(size);
|
||||
|
||||
/* Convert the input to a packet. */
|
||||
auto *packet = reinterpret_cast<const HtcsRpcPacket *>(data);
|
||||
|
||||
/* Complete the task. */
|
||||
this->Complete(static_cast<htcs::SocketError>(packet->params[0]), packet->params[1]);
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result SendTask::CreateRequest(size_t *out, char *data, size_t size, u32 task_id) {
|
||||
AMS_UNUSED(size);
|
||||
|
||||
/* Create the packet. */
|
||||
auto *packet = reinterpret_cast<HtcsRpcPacket *>(data);
|
||||
*packet = {
|
||||
.protocol = HtcsProtocol,
|
||||
.version = this->GetVersion(),
|
||||
.category = HtcsPacketCategory::Request,
|
||||
.type = HtcsPacketType::SendLarge,
|
||||
.body_size = 0,
|
||||
.task_id = task_id,
|
||||
.params = {
|
||||
m_handle,
|
||||
m_size,
|
||||
static_cast<s64>(m_flags),
|
||||
GetSendDataChannelId(task_id),
|
||||
},
|
||||
};
|
||||
|
||||
/* Set the output size. */
|
||||
*out = sizeof(*packet);
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result SendTask::ProcessNotification(const char *data, size_t size) {
|
||||
AMS_UNUSED(data, size);
|
||||
|
||||
this->NotifyDataChannelReady();
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result SendTask::CreateNotification(size_t *out, char *data, size_t size, u32 task_id) {
|
||||
AMS_UNUSED(size);
|
||||
|
||||
/* Create the packet. */
|
||||
auto *packet = reinterpret_cast<HtcsRpcPacket *>(data);
|
||||
*packet = {
|
||||
.protocol = HtcsProtocol,
|
||||
.version = this->GetVersion(),
|
||||
.category = HtcsPacketCategory::Notification,
|
||||
.type = HtcsPacketType::SendLarge,
|
||||
.body_size = 0,
|
||||
.task_id = task_id,
|
||||
.params = {
|
||||
/* ... */
|
||||
},
|
||||
};
|
||||
|
||||
/* Set the output size. */
|
||||
*out = sizeof(*packet);
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,83 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 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 "htcs_rpc_tasks.hpp"
|
||||
|
||||
namespace ams::htcs::impl::rpc {
|
||||
|
||||
Result ShutdownTask::SetArguments(s32 handle, ShutdownType how) {
|
||||
/* Set our arguments. */
|
||||
m_handle = handle;
|
||||
m_how = how;
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
void ShutdownTask::Complete(htcs::SocketError err) {
|
||||
/* Set our results. */
|
||||
m_err = err;
|
||||
|
||||
/* Complete. */
|
||||
HtcsTask::Complete();
|
||||
}
|
||||
|
||||
Result ShutdownTask::GetResult(htcs::SocketError *out_err) const {
|
||||
/* Sanity check our state. */
|
||||
AMS_ASSERT(this->GetTaskState() == htc::server::rpc::RpcTaskState::Completed);
|
||||
|
||||
/* Set the output. */
|
||||
*out_err = m_err;
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result ShutdownTask::ProcessResponse(const char *data, size_t size) {
|
||||
AMS_UNUSED(size);
|
||||
|
||||
/* Convert the input to a packet. */
|
||||
auto *packet = reinterpret_cast<const HtcsRpcPacket *>(data);
|
||||
|
||||
/* Complete the task. */
|
||||
this->Complete(static_cast<htcs::SocketError>(packet->params[0]));
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result ShutdownTask::CreateRequest(size_t *out, char *data, size_t size, u32 task_id) {
|
||||
AMS_UNUSED(size);
|
||||
|
||||
/* Create the packet. */
|
||||
auto *packet = reinterpret_cast<HtcsRpcPacket *>(data);
|
||||
*packet = {
|
||||
.protocol = HtcsProtocol,
|
||||
.version = this->GetVersion(),
|
||||
.category = HtcsPacketCategory::Request,
|
||||
.type = HtcsPacketType::Shutdown,
|
||||
.body_size = 0,
|
||||
.task_id = task_id,
|
||||
.params = {
|
||||
m_handle,
|
||||
static_cast<s64>(m_how),
|
||||
},
|
||||
};
|
||||
|
||||
/* Set the output size. */
|
||||
*out = sizeof(*packet);
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,63 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 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 "htcs_rpc_tasks.hpp"
|
||||
|
||||
namespace ams::htcs::impl::rpc {
|
||||
|
||||
namespace {
|
||||
|
||||
constexpr int MaxEventCount = 0x22;
|
||||
|
||||
constinit os::SdkMutex g_event_count_mutex;
|
||||
constinit int g_event_count = 0;
|
||||
|
||||
}
|
||||
|
||||
HtcsSignalingTask::HtcsSignalingTask(HtcsTaskType type) : HtcsTask(type), m_is_valid(false) {
|
||||
/* Acquire the exclusive right to create an event. */
|
||||
std::scoped_lock lk(g_event_count_mutex);
|
||||
|
||||
/* Create an event. */
|
||||
if (AMS_LIKELY(g_event_count < MaxEventCount)) {
|
||||
/* Make the event. */
|
||||
R_ABORT_UNLESS(os::CreateSystemEvent(std::addressof(m_system_event), os::EventClearMode_ManualClear, true));
|
||||
|
||||
/* Increment the event count. */
|
||||
++g_event_count;
|
||||
|
||||
/* Mark ourselves as valid. */
|
||||
m_is_valid = true;
|
||||
}
|
||||
}
|
||||
|
||||
HtcsSignalingTask::~HtcsSignalingTask() {
|
||||
/* If we have an event, we need to destroy it. */
|
||||
if (AMS_LIKELY(m_is_valid)) {
|
||||
/* Acquire exclusive access to the event count. */
|
||||
std::scoped_lock lk(g_event_count_mutex);
|
||||
|
||||
/* Destroy our event. */
|
||||
os::DestroySystemEvent(std::addressof(m_system_event));
|
||||
|
||||
/* Decrement the event count. */
|
||||
if ((--g_event_count) < 0) {
|
||||
g_event_count = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,93 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 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 "htcs_rpc_tasks.hpp"
|
||||
|
||||
namespace ams::htcs::impl::rpc {
|
||||
|
||||
namespace {
|
||||
|
||||
constinit s16 g_protocol_version = HtcsMaxVersion;
|
||||
|
||||
}
|
||||
|
||||
HtcsTask::HtcsTask(HtcsTaskType type) : m_task_type(type), m_version(g_protocol_version) {
|
||||
/* ... */
|
||||
}
|
||||
|
||||
Result SocketTask::SetArguments() {
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
void SocketTask::Complete(htcs::SocketError err, s32 desc) {
|
||||
/* Set our results. */
|
||||
m_err = err;
|
||||
m_desc = desc;
|
||||
|
||||
/* Complete. */
|
||||
HtcsTask::Complete();
|
||||
}
|
||||
|
||||
Result SocketTask::GetResult(htcs::SocketError *out_err, s32 *out_desc) const {
|
||||
/* Sanity check our state. */
|
||||
AMS_ASSERT(this->GetTaskState() == htc::server::rpc::RpcTaskState::Completed);
|
||||
|
||||
/* Set the output. */
|
||||
*out_err = m_err;
|
||||
*out_desc = m_desc;
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result SocketTask::ProcessResponse(const char *data, size_t size) {
|
||||
AMS_UNUSED(size);
|
||||
|
||||
/* Convert the input to a packet. */
|
||||
auto *packet = reinterpret_cast<const HtcsRpcPacket *>(data);
|
||||
|
||||
/* Update the global protocol version. */
|
||||
g_protocol_version = std::min(g_protocol_version, packet->version);
|
||||
|
||||
/* Complete the task. */
|
||||
this->Complete(static_cast<htcs::SocketError>(packet->params[0]), packet->params[1]);
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result SocketTask::CreateRequest(size_t *out, char *data, size_t size, u32 task_id) {
|
||||
AMS_UNUSED(size);
|
||||
|
||||
/* Create the packet. */
|
||||
auto *packet = reinterpret_cast<HtcsRpcPacket *>(data);
|
||||
*packet = {
|
||||
.protocol = HtcsProtocol,
|
||||
.version = 3,
|
||||
.category = HtcsPacketCategory::Request,
|
||||
.type = HtcsPacketType::Socket,
|
||||
.body_size = 0,
|
||||
.task_id = task_id,
|
||||
.params = {
|
||||
/* ... */
|
||||
},
|
||||
};
|
||||
|
||||
/* Set the output size. */
|
||||
*out = sizeof(*packet);
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,473 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 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/>.
|
||||
*/
|
||||
#pragma once
|
||||
#include <stratosphere.hpp>
|
||||
#include "../../../htc/server/rpc/htc_rpc_tasks.hpp"
|
||||
|
||||
namespace ams::htcs::impl::rpc {
|
||||
|
||||
enum class HtcsTaskType {
|
||||
Receive = 0,
|
||||
Send = 1,
|
||||
Shutdown = 2,
|
||||
Close = 3,
|
||||
Connect = 4,
|
||||
Listen = 5,
|
||||
Accept = 6,
|
||||
Socket = 7,
|
||||
Bind = 8,
|
||||
Fcntl = 9,
|
||||
ReceiveSmall = 10,
|
||||
SendSmall = 11,
|
||||
Select = 12,
|
||||
};
|
||||
|
||||
constexpr inline s16 HtcsProtocol = 5;
|
||||
constexpr inline const s16 HtcsMaxVersion = 4;
|
||||
|
||||
enum class HtcsPacketCategory : s16 {
|
||||
Request = 0,
|
||||
Response = 1,
|
||||
Notification = 2,
|
||||
};
|
||||
|
||||
enum class HtcsPacketType : s16 {
|
||||
Receive = 32,
|
||||
Send = 33,
|
||||
Shutdown = 34,
|
||||
Close = 35,
|
||||
Connect = 36,
|
||||
Listen = 37,
|
||||
Accept = 38,
|
||||
Socket = 39,
|
||||
Bind = 40,
|
||||
Fcntl = 41,
|
||||
ReceiveLarge = 42,
|
||||
SendLarge = 43,
|
||||
Select = 44,
|
||||
};
|
||||
|
||||
struct HtcsRpcPacket {
|
||||
s16 protocol;
|
||||
s16 version;
|
||||
HtcsPacketCategory category;
|
||||
HtcsPacketType type;
|
||||
s64 body_size;
|
||||
u32 task_id{};
|
||||
s64 params[5];
|
||||
char data[];
|
||||
};
|
||||
static_assert(sizeof(HtcsRpcPacket) == 0x40);
|
||||
|
||||
constexpr inline u16 ReceiveDataChannelIdBegin = htc::server::rpc::MaxRpcCount;
|
||||
constexpr inline u16 ReceiveDataChannelIdEnd = ReceiveDataChannelIdBegin + htc::server::rpc::MaxRpcCount;
|
||||
static_assert(ReceiveDataChannelIdEnd - ReceiveDataChannelIdBegin == htc::server::rpc::MaxRpcCount);
|
||||
|
||||
constexpr inline u16 SendDataChannelIdBegin = ReceiveDataChannelIdEnd;
|
||||
constexpr inline u16 SendDataChannelIdEnd = SendDataChannelIdBegin + htc::server::rpc::MaxRpcCount;
|
||||
static_assert(SendDataChannelIdEnd - SendDataChannelIdBegin == htc::server::rpc::MaxRpcCount);
|
||||
|
||||
constexpr inline u16 GetReceiveDataChannelId(u32 task_id) {
|
||||
const u16 channel_id = task_id + ReceiveDataChannelIdBegin;
|
||||
AMS_ASSERT(ReceiveDataChannelIdBegin <= channel_id && channel_id < ReceiveDataChannelIdEnd);
|
||||
|
||||
return channel_id;
|
||||
}
|
||||
|
||||
constexpr inline u16 GetSendDataChannelId(u32 task_id) {
|
||||
const u16 channel_id = task_id + SendDataChannelIdBegin;
|
||||
AMS_ASSERT(SendDataChannelIdBegin <= channel_id && channel_id < SendDataChannelIdEnd);
|
||||
|
||||
return channel_id;
|
||||
}
|
||||
|
||||
class HtcsTask : public htc::server::rpc::Task {
|
||||
private:
|
||||
HtcsTaskType m_task_type;
|
||||
s16 m_version;
|
||||
public:
|
||||
HtcsTask(HtcsTaskType type); /* Defined in socket_task.cpp, for namespacing reasons. */
|
||||
|
||||
HtcsTaskType GetTaskType() const { return m_task_type; }
|
||||
s16 GetVersion() const { return m_version; }
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
concept IsHtcsTask = std::derived_from<T, HtcsTask>;
|
||||
|
||||
class HtcsSignalingTask : public HtcsTask {
|
||||
private:
|
||||
os::SystemEventType m_system_event;
|
||||
bool m_is_valid;
|
||||
public:
|
||||
HtcsSignalingTask(HtcsTaskType type);
|
||||
virtual ~HtcsSignalingTask();
|
||||
|
||||
bool IsValid() const { return m_is_valid; }
|
||||
|
||||
void Complete() {
|
||||
os::SignalSystemEvent(std::addressof(m_system_event));
|
||||
HtcsTask::Complete();
|
||||
}
|
||||
public:
|
||||
virtual void Cancel(htc::server::rpc::RpcTaskCancelReason reason) override {
|
||||
HtcsTask::Cancel(reason);
|
||||
os::SignalSystemEvent(std::addressof(m_system_event));
|
||||
}
|
||||
|
||||
virtual os::SystemEventType *GetSystemEvent() override { return std::addressof(m_system_event); }
|
||||
};
|
||||
|
||||
class ReceiveTask : public HtcsSignalingTask {
|
||||
public:
|
||||
static constexpr inline HtcsTaskType TaskType = HtcsTaskType::Receive;
|
||||
private:
|
||||
s32 m_handle;
|
||||
s64 m_size;
|
||||
htcs::MessageFlag m_flags;
|
||||
void *m_buffer;
|
||||
s64 m_buffer_size;
|
||||
htcs::SocketError m_err;
|
||||
s64 m_result_size;
|
||||
public:
|
||||
ReceiveTask() : HtcsSignalingTask(TaskType) { /* ... */ }
|
||||
|
||||
s32 GetHandle() const { return m_handle; }
|
||||
s64 GetSize() const { return m_size; }
|
||||
htcs::MessageFlag GetFlags() const { return m_flags; }
|
||||
void *GetBuffer() const { return m_buffer; }
|
||||
s64 GetBufferSize() const { return m_buffer_size; }
|
||||
|
||||
s64 GetResultSize() const {
|
||||
AMS_ASSERT(this->GetTaskState() == htc::server::rpc::RpcTaskState::Completed);
|
||||
return m_result_size;
|
||||
}
|
||||
public:
|
||||
Result SetArguments(s32 handle, s64 size, htcs::MessageFlag flags);
|
||||
void Complete(htcs::SocketError err, s64 size);
|
||||
Result GetResult(htcs::SocketError *out_err, s64 *out_size) const;
|
||||
public:
|
||||
virtual Result ProcessResponse(const char *data, size_t size) override;
|
||||
virtual Result CreateRequest(size_t *out, char *data, size_t size, u32 task_id) override;
|
||||
virtual Result CreateNotification(size_t *out, char *data, size_t size, u32 task_id) override;
|
||||
};
|
||||
|
||||
class SendTask : public HtcsSignalingTask {
|
||||
public:
|
||||
static constexpr inline HtcsTaskType TaskType = HtcsTaskType::Send;
|
||||
private:
|
||||
os::Event m_ready_event;
|
||||
s32 m_handle;
|
||||
s64 m_size;
|
||||
htcs::MessageFlag m_flags;
|
||||
const void *m_buffer;
|
||||
s64 m_buffer_size;
|
||||
htcs::SocketError m_err;
|
||||
s64 m_result_size;
|
||||
public:
|
||||
SendTask() : HtcsSignalingTask(TaskType), m_ready_event(os::EventClearMode_ManualClear) { /* ... */ }
|
||||
|
||||
s32 GetHandle() const { return m_handle; }
|
||||
s64 GetSize() const { return m_size; }
|
||||
htcs::MessageFlag GetFlags() const { return m_flags; }
|
||||
const void *GetBuffer() const { return m_buffer; }
|
||||
s64 GetBufferSize() const { return m_buffer_size; }
|
||||
|
||||
void SetBuffer(const void *buffer, s64 buffer_size);
|
||||
void NotifyDataChannelReady();
|
||||
void WaitNotification();
|
||||
public:
|
||||
Result SetArguments(s32 handle, s64 size, htcs::MessageFlag flags);
|
||||
void Complete(htcs::SocketError err, s64 size);
|
||||
Result GetResult(htcs::SocketError *out_err, s64 *out_size) const;
|
||||
public:
|
||||
virtual void Cancel(htc::server::rpc::RpcTaskCancelReason reason) override;
|
||||
virtual Result ProcessResponse(const char *data, size_t size) override;
|
||||
virtual Result CreateRequest(size_t *out, char *data, size_t size, u32 task_id) override;
|
||||
virtual Result ProcessNotification(const char *data, size_t size) override;
|
||||
virtual Result CreateNotification(size_t *out, char *data, size_t size, u32 task_id) override;
|
||||
};
|
||||
|
||||
class ShutdownTask : public HtcsTask {
|
||||
public:
|
||||
static constexpr inline HtcsTaskType TaskType = HtcsTaskType::Shutdown;
|
||||
private:
|
||||
s32 m_handle;
|
||||
ShutdownType m_how;
|
||||
htcs::SocketError m_err;
|
||||
public:
|
||||
ShutdownTask() : HtcsTask(TaskType) { /* ... */ }
|
||||
|
||||
s32 GetHandle() const { return m_handle; }
|
||||
ShutdownType GetHow() const { return m_how; }
|
||||
public:
|
||||
Result SetArguments(s32 handle, ShutdownType how);
|
||||
void Complete(htcs::SocketError err);
|
||||
Result GetResult(htcs::SocketError *out_err) const;
|
||||
public:
|
||||
virtual Result ProcessResponse(const char *data, size_t size) override;
|
||||
virtual Result CreateRequest(size_t *out, char *data, size_t size, u32 task_id) override;
|
||||
};
|
||||
|
||||
class CloseTask : public HtcsTask {
|
||||
public:
|
||||
static constexpr inline HtcsTaskType TaskType = HtcsTaskType::Close;
|
||||
private:
|
||||
s32 m_handle;
|
||||
htcs::SocketError m_err;
|
||||
public:
|
||||
CloseTask() : HtcsTask(TaskType) { /* ... */ }
|
||||
|
||||
s32 GetHandle() const { return m_handle; }
|
||||
public:
|
||||
Result SetArguments(s32 handle);
|
||||
void Complete(htcs::SocketError err);
|
||||
Result GetResult(htcs::SocketError *out_err) const;
|
||||
public:
|
||||
virtual Result ProcessResponse(const char *data, size_t size) override;
|
||||
virtual Result CreateRequest(size_t *out, char *data, size_t size, u32 task_id) override;
|
||||
};
|
||||
|
||||
class ConnectTask : public HtcsTask {
|
||||
public:
|
||||
static constexpr inline HtcsTaskType TaskType = HtcsTaskType::Connect;
|
||||
private:
|
||||
s32 m_handle;
|
||||
HtcsPeerName m_peer_name;
|
||||
HtcsPortName m_port_name;
|
||||
htcs::SocketError m_err;
|
||||
public:
|
||||
ConnectTask() : HtcsTask(TaskType) { /* ... */ }
|
||||
|
||||
s32 GetHandle() const { return m_handle; }
|
||||
const HtcsPeerName &GetPeerName() const { return m_peer_name; }
|
||||
const HtcsPortName &GetPortName() const { return m_port_name; }
|
||||
public:
|
||||
Result SetArguments(s32 handle, const HtcsPeerName &peer_name, const HtcsPortName &port_name);
|
||||
void Complete(htcs::SocketError err);
|
||||
Result GetResult(htcs::SocketError *out_err) const;
|
||||
public:
|
||||
virtual Result ProcessResponse(const char *data, size_t size) override;
|
||||
virtual Result CreateRequest(size_t *out, char *data, size_t size, u32 task_id) override;
|
||||
};
|
||||
|
||||
class ListenTask : public HtcsTask {
|
||||
public:
|
||||
static constexpr inline HtcsTaskType TaskType = HtcsTaskType::Listen;
|
||||
private:
|
||||
s32 m_handle;
|
||||
s32 m_backlog;
|
||||
htcs::SocketError m_err;
|
||||
public:
|
||||
ListenTask() : HtcsTask(TaskType) { /* ... */ }
|
||||
|
||||
s32 GetHandle() const { return m_handle; }
|
||||
s32 GetBacklog() const { return m_backlog; }
|
||||
public:
|
||||
Result SetArguments(s32 handle, s32 backlog);
|
||||
void Complete(htcs::SocketError err);
|
||||
Result GetResult(htcs::SocketError *out_err) const;
|
||||
public:
|
||||
virtual Result ProcessResponse(const char *data, size_t size) override;
|
||||
virtual Result CreateRequest(size_t *out, char *data, size_t size, u32 task_id) override;
|
||||
};
|
||||
|
||||
class AcceptTask : public HtcsSignalingTask {
|
||||
public:
|
||||
static constexpr inline HtcsTaskType TaskType = HtcsTaskType::Accept;
|
||||
private:
|
||||
s32 m_server_handle;
|
||||
htcs::SocketError m_err;
|
||||
s32 m_desc;
|
||||
public:
|
||||
AcceptTask() : HtcsSignalingTask(TaskType) { /* ... */ }
|
||||
|
||||
s32 GetServerHandle() const { return m_server_handle; }
|
||||
public:
|
||||
Result SetArguments(s32 server_handle);
|
||||
void Complete(htcs::SocketError err, s32 desc);
|
||||
Result GetResult(htcs::SocketError *out_err, s32 *out_desc, s32 server_handle) const;
|
||||
public:
|
||||
virtual Result ProcessResponse(const char *data, size_t size) override;
|
||||
virtual Result CreateRequest(size_t *out, char *data, size_t size, u32 task_id) override;
|
||||
};
|
||||
|
||||
class SocketTask : public HtcsTask {
|
||||
public:
|
||||
static constexpr inline HtcsTaskType TaskType = HtcsTaskType::Socket;
|
||||
private:
|
||||
htcs::SocketError m_err;
|
||||
s32 m_desc;
|
||||
public:
|
||||
SocketTask() : HtcsTask(TaskType) { /* ... */ }
|
||||
public:
|
||||
Result SetArguments();
|
||||
void Complete(htcs::SocketError err, s32 desc);
|
||||
Result GetResult(htcs::SocketError *out_err, s32 *out_desc) const;
|
||||
public:
|
||||
virtual Result ProcessResponse(const char *data, size_t size) override;
|
||||
virtual Result CreateRequest(size_t *out, char *data, size_t size, u32 task_id) override;
|
||||
};
|
||||
|
||||
class BindTask : public HtcsTask {
|
||||
public:
|
||||
static constexpr inline HtcsTaskType TaskType = HtcsTaskType::Bind;
|
||||
private:
|
||||
s32 m_handle;
|
||||
HtcsPeerName m_peer_name;
|
||||
HtcsPortName m_port_name;
|
||||
htcs::SocketError m_err;
|
||||
public:
|
||||
BindTask() : HtcsTask(TaskType) { /* ... */ }
|
||||
|
||||
s32 GetHandle() const { return m_handle; }
|
||||
const HtcsPeerName &GetPeerName() const { return m_peer_name; }
|
||||
const HtcsPortName &GetPortName() const { return m_port_name; }
|
||||
public:
|
||||
Result SetArguments(s32 handle, const HtcsPeerName &peer_name, const HtcsPortName &port_name);
|
||||
void Complete(htcs::SocketError err);
|
||||
Result GetResult(htcs::SocketError *out_err) const;
|
||||
public:
|
||||
virtual Result ProcessResponse(const char *data, size_t size) override;
|
||||
virtual Result CreateRequest(size_t *out, char *data, size_t size, u32 task_id) override;
|
||||
};
|
||||
|
||||
class FcntlTask : public HtcsTask {
|
||||
public:
|
||||
static constexpr inline HtcsTaskType TaskType = HtcsTaskType::Fcntl;
|
||||
private:
|
||||
s32 m_handle;
|
||||
s32 m_command;
|
||||
s32 m_value;
|
||||
htcs::SocketError m_err;
|
||||
s32 m_res;
|
||||
public:
|
||||
FcntlTask() : HtcsTask(TaskType) { /* ... */ }
|
||||
|
||||
s32 GetHandle() const { return m_handle; }
|
||||
s32 GetCommand() const { return m_command; }
|
||||
s32 GetValue() const { return m_value; }
|
||||
public:
|
||||
Result SetArguments(s32 handle, s32 command, s32 value);
|
||||
void Complete(htcs::SocketError err, s32 res);
|
||||
Result GetResult(htcs::SocketError *out_err, s32 *out_res) const;
|
||||
public:
|
||||
virtual Result ProcessResponse(const char *data, size_t size) override;
|
||||
virtual Result CreateRequest(size_t *out, char *data, size_t size, u32 task_id) override;
|
||||
};
|
||||
|
||||
class ReceiveSmallTask : public HtcsSignalingTask {
|
||||
public:
|
||||
static constexpr inline HtcsTaskType TaskType = HtcsTaskType::ReceiveSmall;
|
||||
private:
|
||||
s32 m_handle;
|
||||
s64 m_size;
|
||||
htcs::MessageFlag m_flags;
|
||||
char m_buffer[0xE000];
|
||||
htcs::SocketError m_err;
|
||||
s64 m_result_size;
|
||||
public:
|
||||
ReceiveSmallTask() : HtcsSignalingTask(TaskType) { /* ... */ }
|
||||
|
||||
s32 GetHandle() const { return m_handle; }
|
||||
s64 GetSize() const { return m_size; }
|
||||
htcs::MessageFlag GetFlags() const { return m_flags; }
|
||||
void *GetBuffer() { return m_buffer; }
|
||||
s64 GetBufferSize() const { return static_cast<s64>(sizeof(m_buffer)); }
|
||||
|
||||
s64 GetResultSize() const {
|
||||
AMS_ASSERT(this->GetTaskState() == htc::server::rpc::RpcTaskState::Completed);
|
||||
return m_result_size;
|
||||
}
|
||||
public:
|
||||
Result SetArguments(s32 handle, s64 size, htcs::MessageFlag flags);
|
||||
void Complete(htcs::SocketError err, s64 size);
|
||||
Result GetResult(htcs::SocketError *out_err, s64 *out_size) const;
|
||||
public:
|
||||
virtual Result ProcessResponse(const char *data, size_t size) override;
|
||||
virtual Result CreateRequest(size_t *out, char *data, size_t size, u32 task_id) override;
|
||||
virtual bool IsReceiveBufferRequired() override;
|
||||
};
|
||||
|
||||
class SendSmallTask : public HtcsSignalingTask {
|
||||
public:
|
||||
static constexpr inline HtcsTaskType TaskType = HtcsTaskType::SendSmall;
|
||||
private:
|
||||
os::Event m_ready_event;
|
||||
s32 m_handle;
|
||||
s64 m_size;
|
||||
htcs::MessageFlag m_flags;
|
||||
char m_buffer[0xE000];
|
||||
s64 m_buffer_size;
|
||||
htcs::SocketError m_err;
|
||||
s64 m_result_size;
|
||||
public:
|
||||
SendSmallTask() : HtcsSignalingTask(TaskType), m_ready_event(os::EventClearMode_ManualClear) { /* ... */ }
|
||||
|
||||
s32 GetHandle() const { return m_handle; }
|
||||
s64 GetSize() const { return m_size; }
|
||||
htcs::MessageFlag GetFlags() const { return m_flags; }
|
||||
void *GetBuffer() { return m_buffer; }
|
||||
s64 GetBufferSize() const { return m_buffer_size; }
|
||||
|
||||
void SetBuffer(const void *buffer, s64 buffer_size);
|
||||
void NotifyDataChannelReady();
|
||||
void WaitNotification();
|
||||
public:
|
||||
Result SetArguments(s32 handle, s64 size, htcs::MessageFlag flags);
|
||||
void Complete(htcs::SocketError err, s64 size);
|
||||
Result GetResult(htcs::SocketError *out_err, s64 *out_size) const;
|
||||
public:
|
||||
virtual void Cancel(htc::server::rpc::RpcTaskCancelReason reason) override;
|
||||
virtual Result ProcessResponse(const char *data, size_t size) override;
|
||||
virtual Result CreateRequest(size_t *out, char *data, size_t size, u32 task_id) override;
|
||||
virtual bool IsSendBufferRequired() override;
|
||||
};
|
||||
|
||||
class SelectTask : public HtcsSignalingTask {
|
||||
public:
|
||||
static constexpr inline HtcsTaskType TaskType = HtcsTaskType::Select;
|
||||
private:
|
||||
s32 m_handles[SocketCountMax * 3];
|
||||
s32 m_read_handle_count;
|
||||
s32 m_write_handle_count;
|
||||
s32 m_exception_handle_count;
|
||||
s64 m_tv_sec;
|
||||
s64 m_tv_usec;
|
||||
htcs::SocketError m_err;
|
||||
s32 m_out_handles[SocketCountMax * 3];
|
||||
s32 m_out_read_handle_count;
|
||||
s32 m_out_write_handle_count;
|
||||
s32 m_out_exception_handle_count;
|
||||
public:
|
||||
SelectTask() : HtcsSignalingTask(TaskType) { /* ... */ }
|
||||
|
||||
const s32 *GetHandles() const { return m_handles; }
|
||||
s32 GetReadHandleCount() const { return m_read_handle_count; }
|
||||
s32 GetWriteHandleCount() const { return m_write_handle_count; }
|
||||
s32 GetExceptionHandleCount() const { return m_exception_handle_count; }
|
||||
s64 GetTimeoutSeconds() const { return m_tv_sec; }
|
||||
s64 GetTimeoutMicroSeconds() const { return m_tv_usec; }
|
||||
public:
|
||||
Result SetArguments(Span<const int> read_handles, Span<const int> write_handles, Span<const int> exception_handles, s64 tv_sec, s64 tv_usec);
|
||||
void Complete(htcs::SocketError err, s32 read_handle_count, s32 write_handle_count, s32 exception_handle_count, const void *body, s64 body_size);
|
||||
Result GetResult(htcs::SocketError *out_err, bool *out_empty, Span<int> read_handles, Span<int> write_handles, Span<int> exception_handles) const;
|
||||
public:
|
||||
virtual Result ProcessResponse(const char *data, size_t size) override;
|
||||
virtual Result CreateRequest(size_t *out, char *data, size_t size, u32 task_id) override;
|
||||
};
|
||||
|
||||
}
|
||||
Reference in New Issue
Block a user