mirror of
https://github.com/Atmosphere-NX/Atmosphere.git
synced 2025-05-31 14:58:22 -04:00
htcs: hook up HtcsService to rpc client
This commit is contained in:
Michael Scire
SciresM
parent
0c791f2279
commit
7667104961
18 changed files with 733 additions and 77 deletions
|
|
@ -296,7 +296,7 @@ namespace ams::htcs::impl {
|
|||
s64 size;
|
||||
R_TRY_CATCH(m_impl->ContinueSend(std::addressof(size), buffer, buffer_size, task_id, desc)) {
|
||||
R_CONVERT(htclow::ResultInvalidChannelState, tma::ResultUnknown())
|
||||
R_CONVERT(htc::ResultUnknown2021, tma::ResultUnknown())
|
||||
R_CONVERT(htc::ResultTaskCancelled, tma::ResultUnknown())
|
||||
} R_END_TRY_CATCH;
|
||||
|
||||
/* Set output. */
|
||||
|
|
@ -359,7 +359,7 @@ namespace ams::htcs::impl {
|
|||
Result HtcsManager::StartSelect(u32 *out_task_id, Handle *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::ResultUnknown2021, tma::ResultUnknown())
|
||||
R_CONVERT(htc::ResultTaskCancelled, tma::ResultUnknown())
|
||||
} R_END_TRY_CATCH;
|
||||
|
||||
return ResultSuccess();
|
||||
|
|
@ -367,11 +367,12 @@ namespace ams::htcs::impl {
|
|||
|
||||
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, res;
|
||||
const Result result = m_impl->EndSelect(std::addressof(err), std::addressof(res), read_handles, write_handles, exception_handles, task_id);
|
||||
s32 err;
|
||||
bool empty;
|
||||
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) && res == 0) {
|
||||
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; });
|
||||
|
|
|
|||
|
|
@ -107,7 +107,7 @@ namespace ams::htcs::impl {
|
|||
/* 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::ResultUnknown2023::Includes(result) || htc::ResultTaskQueueNotAvailable::Includes(result)) {
|
||||
if (R_SUCCEEDED(result) || htcs::ResultCompleted::Includes(result) || htc::ResultTaskQueueNotAvailable::Includes(result)) {
|
||||
*out_task_id = task_id;
|
||||
*out_handle = handle;
|
||||
} else {
|
||||
|
|
@ -162,12 +162,13 @@ namespace ams::htcs::impl {
|
|||
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::ResultUnknown2021::Includes(result)) {
|
||||
if (htcs::ResultCancelled::Includes(result)) {
|
||||
os::SystemEventType event;
|
||||
os::AttachReadableHandleToSystemEvent(std::addressof(event), handle, true, os::EventClearMode_ManualClear);
|
||||
|
||||
s32 err, res;
|
||||
m_service.SelectEnd(std::addressof(err), std::addressof(res), Span<int>{}, Span<int>{}, Span<int>{}, task_id);
|
||||
s32 err;
|
||||
bool empty;
|
||||
m_service.SelectEnd(std::addressof(err), std::addressof(empty), Span<int>{}, Span<int>{}, Span<int>{}, task_id);
|
||||
|
||||
os::DestroySystemEvent(std::addressof(event));
|
||||
} else {
|
||||
|
|
@ -178,8 +179,8 @@ namespace ams::htcs::impl {
|
|||
return result;
|
||||
}
|
||||
|
||||
Result HtcsManagerImpl::EndSelect(s32 *out_err, s32 *out_res, Span<int> read_handles, Span<int> write_handles, Span<int> exception_handles, u32 task_id) {
|
||||
return m_service.SelectEnd(out_err, out_res, read_handles, write_handles, exception_handles, task_id);
|
||||
Result HtcsManagerImpl::EndSelect(s32 *out_err, bool *out_empty, Span<int> read_handles, Span<int> write_handles, Span<int> exception_handles, u32 task_id) {
|
||||
return m_service.SelectEnd(out_err, out_empty, read_handles, write_handles, exception_handles, task_id);
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -70,7 +70,7 @@ namespace ams::htcs::impl {
|
|||
Result EndRecv(s32 *out_err, s64 *out_size, char *buffer, s64 buffer_size, u32 task_id, s32 desc);
|
||||
|
||||
Result StartSelect(u32 *out_task_id, Handle *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_res, Span<int> read_handles, Span<int> write_handles, Span<int> exception_handles, u32 task_id);
|
||||
Result EndSelect(s32 *out_err, bool *out_empty, Span<int> read_handles, Span<int> write_handles, Span<int> exception_handles, u32 task_id);
|
||||
};
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -82,7 +82,7 @@ namespace ams::htcs::impl {
|
|||
R_TRY(m_rpc_client->End<rpc::ConnectTask>(task_id, std::addressof(err)));
|
||||
|
||||
/* Set output. */
|
||||
*out_err = err;
|
||||
*out_err = err;
|
||||
return ResultSuccess();
|
||||
}
|
||||
|
||||
|
|
@ -104,34 +104,302 @@ namespace ams::htcs::impl {
|
|||
R_TRY(m_rpc_client->End<rpc::BindTask>(task_id, std::addressof(err)));
|
||||
|
||||
/* Set output. */
|
||||
*out_err = err;
|
||||
*out_err = err;
|
||||
return ResultSuccess();
|
||||
}
|
||||
|
||||
Result HtcsService::Listen(s32 *out_err, s32 desc, s32 backlog_count);
|
||||
Result HtcsService::Receive(s32 *out_err, s64 *out_size, char *buffer, size_t size, s32 desc, s32 flags);
|
||||
Result HtcsService::Send(s32 *out_err, s64 *out_size, const char *buffer, size_t size, s32 desc, s32 flags);
|
||||
Result HtcsService::Shutdown(s32 *out_err, s32 desc, s32 how);
|
||||
Result HtcsService::Fcntl(s32 *out_err, s32 *out_res, s32 desc, s32 command, s32 value);
|
||||
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));
|
||||
|
||||
Result HtcsService::AcceptStart(u32 *out_task_id, Handle *out_handle, s32 desc);
|
||||
Result HtcsService::AcceptResults(s32 *out_err, s32 *out_desc, SockAddrHtcs *out_address, u32 task_id, s32 desc);
|
||||
/* Wait for the task to complete. */
|
||||
this->WaitTask(task_id);
|
||||
|
||||
Result HtcsService::ReceiveSmallStart(u32 *out_task_id, Handle *out_handle, s64 size, s32 desc, s32 flags);
|
||||
Result HtcsService::ReceiveSmallResults(s32 *out_err, s64 *out_size, char *buffer, s64 buffer_size, u32 task_id, s32 desc);
|
||||
/* Finish the task. */
|
||||
htcs::SocketError err;
|
||||
R_TRY(m_rpc_client->End<rpc::ListenTask>(task_id, std::addressof(err)));
|
||||
|
||||
Result HtcsService::SendSmallStart(u32 *out_task_id, Handle *out_handle, s32 desc, s64 size, s32 flags);
|
||||
Result HtcsService::SendSmallContinue(s64 *out_size, const char *buffer, s64 buffer_size, u32 task_id, s32 desc);
|
||||
Result HtcsService::SendSmallResults(s32 *out_err, s64 *out_size, u32 task_id, s32 desc);
|
||||
/* Set output. */
|
||||
*out_err = err;
|
||||
return ResultSuccess();
|
||||
}
|
||||
|
||||
Result HtcsService::SendStart(u32 *out_task_id, Handle *out_handle, s32 desc, s64 size, s32 flags);
|
||||
Result HtcsService::SendContinue(s64 *out_size, const char *buffer, s64 buffer_size, u32 task_id, s32 desc);
|
||||
Result HtcsService::SendResults(s32 *out_err, s64 *out_size, u32 task_id, s32 desc);
|
||||
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)));
|
||||
|
||||
Result HtcsService::ReceiveStart(u32 *out_task_id, Handle *out_handle, s64 size, s32 desc, s32 flags);
|
||||
Result HtcsService::ReceiveResults(s32 *out_err, s64 *out_size, char *buffer, s64 buffer_size, u32 task_id, s32 desc);
|
||||
/* Wait for the task to complete. */
|
||||
this->WaitTask(task_id);
|
||||
|
||||
Result HtcsService::SelectStart(u32 *out_task_id, Handle *out_handle, Span<const int> read_handles, Span<const int> write_handles, Span<const int> exception_handles, s64 tv_sec, s64 tv_usec);
|
||||
Result HtcsService::SelectEnd(s32 *out_err, s32 *out_res, Span<int> read_handles, Span<int> write_handles, Span<int> exception_handles, u32 task_id);
|
||||
/* Finish the task. */
|
||||
R_TRY(this->ReceiveResults(out_err, out_size, buffer, size, task_id, desc));
|
||||
|
||||
return ResultSuccess();
|
||||
}
|
||||
|
||||
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)) {
|
||||
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));
|
||||
|
||||
return ResultSuccess();
|
||||
}
|
||||
|
||||
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;
|
||||
return ResultSuccess();
|
||||
}
|
||||
|
||||
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;
|
||||
return ResultSuccess();
|
||||
}
|
||||
|
||||
Result HtcsService::AcceptStart(u32 *out_task_id, Handle *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);
|
||||
|
||||
return ResultSuccess();
|
||||
}
|
||||
|
||||
Result HtcsService::AcceptResults(s32 *out_err, s32 *out_desc, SockAddrHtcs *out_address, u32 task_id, s32 desc) {
|
||||
/* 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;
|
||||
return ResultSuccess();
|
||||
}
|
||||
|
||||
Result HtcsService::ReceiveSmallStart(u32 *out_task_id, Handle *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);
|
||||
|
||||
return ResultSuccess();
|
||||
}
|
||||
|
||||
Result HtcsService::ReceiveSmallResults(s32 *out_err, s64 *out_size, char *buffer, s64 buffer_size, u32 task_id, s32 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;
|
||||
return ResultSuccess();
|
||||
}
|
||||
|
||||
Result HtcsService::SendSmallStart(u32 *out_task_id, Handle *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);
|
||||
|
||||
return ResultSuccess();
|
||||
}
|
||||
|
||||
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->VerifyTaskIdWitHandle<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;
|
||||
return ResultSuccess();
|
||||
}
|
||||
|
||||
Result HtcsService::SendSmallResults(s32 *out_err, s64 *out_size, u32 task_id, s32 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;
|
||||
return ResultSuccess();
|
||||
}
|
||||
|
||||
Result HtcsService::SendStart(u32 *out_task_id, Handle *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);
|
||||
|
||||
return ResultSuccess();
|
||||
}
|
||||
|
||||
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->VerifyTaskIdWitHandle<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));
|
||||
}
|
||||
|
||||
return ResultSuccess();
|
||||
}
|
||||
|
||||
Result HtcsService::SendResults(s32 *out_err, s64 *out_size, u32 task_id, s32 desc) {
|
||||
/* Verify the task. */
|
||||
R_TRY(m_rpc_client->VerifyTaskIdWitHandle<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;
|
||||
return ResultSuccess();
|
||||
}
|
||||
|
||||
Result HtcsService::ReceiveStart(u32 *out_task_id, Handle *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);
|
||||
|
||||
return ResultSuccess();
|
||||
}
|
||||
|
||||
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->VerifyTaskIdWitHandle<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;
|
||||
return ResultSuccess();
|
||||
}
|
||||
|
||||
/* 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;
|
||||
return ResultSuccess();
|
||||
}
|
||||
|
||||
Result HtcsService::SelectStart(u32 *out_task_id, Handle *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));
|
||||
|
||||
/* Check that the task isn't cancelled. */
|
||||
R_UNLESS(!m_rpc_client->IsCancelled<rpc::SelectTask>(task_id), htcs::ResultCancelled());
|
||||
|
||||
/* Detach the task. */
|
||||
*out_task_id = task_id;
|
||||
*out_handle = m_rpc_client->DetachReadableHandle(task_id);
|
||||
|
||||
return ResultSuccess();
|
||||
}
|
||||
|
||||
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;
|
||||
return ResultSuccess();
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -38,8 +38,8 @@ namespace ams::htcs::impl {
|
|||
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 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);
|
||||
|
||||
|
|
@ -61,7 +61,7 @@ namespace ams::htcs::impl {
|
|||
Result ReceiveResults(s32 *out_err, s64 *out_size, char *buffer, s64 buffer_size, u32 task_id, s32 desc);
|
||||
|
||||
Result SelectStart(u32 *out_task_id, Handle *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, s32 *out_res, Span<int> read_handles, Span<int> write_handles, Span<int> exception_handles, u32 task_id);
|
||||
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);
|
||||
};
|
||||
|
|
|
|||
|
|
@ -29,7 +29,7 @@ namespace ams::htcs::impl {
|
|||
R_CATCH(htcs::ResultInvalidHandle) { return HTCS_EBADF; }
|
||||
R_CATCH(htc::ResultUnknown2001) { return HTCS_EINVAL; }
|
||||
R_CATCH(htc::ResultUnknown2101) { return HTCS_EMFILE; }
|
||||
R_CATCH(htc::ResultUnknown2021) { return HTCS_EINTR; }
|
||||
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; }
|
||||
|
|
|
|||
|
|
@ -28,7 +28,8 @@ namespace ams::htcs::impl::rpc {
|
|||
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:
|
||||
/* TODO */
|
||||
Result Send(const void *buffer, s64 buffer_size, u32 task_id);
|
||||
Result Receive(void *buffer, s64 buffer_size, u32 task_id);
|
||||
};
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -48,6 +48,9 @@ namespace ams::htcs::impl::rpc {
|
|||
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;
|
||||
|
|
@ -72,6 +75,8 @@ namespace ams::htcs::impl::rpc {
|
|||
};
|
||||
|
||||
class ReceiveTask : public HtcsSignalingTask {
|
||||
public:
|
||||
static constexpr inline HtcsTaskType TaskType = HtcsTaskType::Receive;
|
||||
private:
|
||||
s32 m_handle;
|
||||
s64 m_size;
|
||||
|
|
@ -81,7 +86,7 @@ namespace ams::htcs::impl::rpc {
|
|||
htcs::SocketError m_err;
|
||||
s64 m_result_size;
|
||||
public:
|
||||
ReceiveTask() : HtcsSignalingTask(HtcsTaskType::Receive) { /* ... */ }
|
||||
ReceiveTask() : HtcsSignalingTask(TaskType) { /* ... */ }
|
||||
|
||||
s32 GetHandle() const { return m_handle; }
|
||||
s64 GetSize() const { return m_size; }
|
||||
|
|
@ -104,6 +109,8 @@ namespace ams::htcs::impl::rpc {
|
|||
};
|
||||
|
||||
class SendTask : public HtcsSignalingTask {
|
||||
public:
|
||||
static constexpr inline HtcsTaskType TaskType = HtcsTaskType::Send;
|
||||
private:
|
||||
os::Event m_ready_event;
|
||||
s32 m_handle;
|
||||
|
|
@ -114,7 +121,7 @@ namespace ams::htcs::impl::rpc {
|
|||
htcs::SocketError m_err;
|
||||
s64 m_result_size;
|
||||
public:
|
||||
SendTask() : HtcsSignalingTask(HtcsTaskType::Send), m_ready_event(os::EventClearMode_ManualClear) { /* ... */ }
|
||||
SendTask() : HtcsSignalingTask(TaskType), m_ready_event(os::EventClearMode_ManualClear) { /* ... */ }
|
||||
|
||||
s32 GetHandle() const { return m_handle; }
|
||||
s64 GetSize() const { return m_size; }
|
||||
|
|
@ -138,12 +145,14 @@ namespace ams::htcs::impl::rpc {
|
|||
};
|
||||
|
||||
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(HtcsTaskType::Shutdown) { /* ... */ }
|
||||
ShutdownTask() : HtcsTask(TaskType) { /* ... */ }
|
||||
|
||||
s32 GetHandle() const { return m_handle; }
|
||||
ShutdownType GetHow() const { return m_how; }
|
||||
|
|
@ -157,11 +166,13 @@ namespace ams::htcs::impl::rpc {
|
|||
};
|
||||
|
||||
class CloseTask : public HtcsTask {
|
||||
public:
|
||||
static constexpr inline HtcsTaskType TaskType = HtcsTaskType::Close;
|
||||
private:
|
||||
s32 m_handle;
|
||||
htcs::SocketError m_err;
|
||||
public:
|
||||
CloseTask() : HtcsTask(HtcsTaskType::Close) { /* ... */ }
|
||||
CloseTask() : HtcsTask(TaskType) { /* ... */ }
|
||||
|
||||
s32 GetHandle() const { return m_handle; }
|
||||
public:
|
||||
|
|
@ -174,13 +185,15 @@ namespace ams::htcs::impl::rpc {
|
|||
};
|
||||
|
||||
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(HtcsTaskType::Connect) { /* ... */ }
|
||||
ConnectTask() : HtcsTask(TaskType) { /* ... */ }
|
||||
|
||||
s32 GetHandle() const { return m_handle; }
|
||||
const HtcsPeerName &GetPeerName() const { return m_peer_name; }
|
||||
|
|
@ -195,12 +208,14 @@ namespace ams::htcs::impl::rpc {
|
|||
};
|
||||
|
||||
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(HtcsTaskType::Listen) { /* ... */ }
|
||||
ListenTask() : HtcsTask(TaskType) { /* ... */ }
|
||||
|
||||
s32 GetHandle() const { return m_handle; }
|
||||
s32 GetBacklog() const { return m_backlog; }
|
||||
|
|
@ -214,12 +229,14 @@ namespace ams::htcs::impl::rpc {
|
|||
};
|
||||
|
||||
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(HtcsTaskType::Accept) { /* ... */ }
|
||||
AcceptTask() : HtcsSignalingTask(TaskType) { /* ... */ }
|
||||
|
||||
s32 GetServerHandle() const { return m_server_handle; }
|
||||
public:
|
||||
|
|
@ -232,11 +249,13 @@ namespace ams::htcs::impl::rpc {
|
|||
};
|
||||
|
||||
class SocketTask : public HtcsTask {
|
||||
public:
|
||||
static constexpr inline HtcsTaskType TaskType = HtcsTaskType::Socket;
|
||||
private:
|
||||
htcs::SocketError m_err;
|
||||
s32 m_desc;
|
||||
public:
|
||||
SocketTask() : HtcsTask(HtcsTaskType::Socket) { /* ... */ }
|
||||
SocketTask() : HtcsTask(TaskType) { /* ... */ }
|
||||
public:
|
||||
Result SetArguments();
|
||||
void Complete(htcs::SocketError err, s32 desc);
|
||||
|
|
@ -247,13 +266,15 @@ namespace ams::htcs::impl::rpc {
|
|||
};
|
||||
|
||||
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(HtcsTaskType::Bind) { /* ... */ }
|
||||
BindTask() : HtcsTask(TaskType) { /* ... */ }
|
||||
|
||||
s32 GetHandle() const { return m_handle; }
|
||||
const HtcsPeerName &GetPeerName() const { return m_peer_name; }
|
||||
|
|
@ -268,6 +289,8 @@ namespace ams::htcs::impl::rpc {
|
|||
};
|
||||
|
||||
class FcntlTask : public HtcsTask {
|
||||
public:
|
||||
static constexpr inline HtcsTaskType TaskType = HtcsTaskType::Fcntl;
|
||||
private:
|
||||
s32 m_handle;
|
||||
s32 m_command;
|
||||
|
|
@ -275,7 +298,7 @@ namespace ams::htcs::impl::rpc {
|
|||
htcs::SocketError m_err;
|
||||
s32 m_res;
|
||||
public:
|
||||
FcntlTask() : HtcsTask(HtcsTaskType::Fcntl) { /* ... */ }
|
||||
FcntlTask() : HtcsTask(TaskType) { /* ... */ }
|
||||
|
||||
s32 GetHandle() const { return m_handle; }
|
||||
s32 GetCommand() const { return m_command; }
|
||||
|
|
@ -290,6 +313,8 @@ namespace ams::htcs::impl::rpc {
|
|||
};
|
||||
|
||||
class ReceiveSmallTask : public HtcsSignalingTask {
|
||||
public:
|
||||
static constexpr inline HtcsTaskType TaskType = HtcsTaskType::ReceiveSmall;
|
||||
private:
|
||||
s32 m_handle;
|
||||
s64 m_size;
|
||||
|
|
@ -298,7 +323,7 @@ namespace ams::htcs::impl::rpc {
|
|||
htcs::SocketError m_err;
|
||||
s64 m_result_size;
|
||||
public:
|
||||
ReceiveSmallTask() : HtcsSignalingTask(HtcsTaskType::ReceiveSmall) { /* ... */ }
|
||||
ReceiveSmallTask() : HtcsSignalingTask(TaskType) { /* ... */ }
|
||||
|
||||
s32 GetHandle() const { return m_handle; }
|
||||
s64 GetSize() const { return m_size; }
|
||||
|
|
@ -321,6 +346,8 @@ namespace ams::htcs::impl::rpc {
|
|||
};
|
||||
|
||||
class SendSmallTask : public HtcsSignalingTask {
|
||||
public:
|
||||
static constexpr inline HtcsTaskType TaskType = HtcsTaskType::SendSmall;
|
||||
private:
|
||||
os::Event m_ready_event;
|
||||
s32 m_handle;
|
||||
|
|
@ -331,7 +358,7 @@ namespace ams::htcs::impl::rpc {
|
|||
htcs::SocketError m_err;
|
||||
s64 m_result_size;
|
||||
public:
|
||||
SendSmallTask() : HtcsSignalingTask(HtcsTaskType::SendSmall), m_ready_event(os::EventClearMode_ManualClear) { /* ... */ }
|
||||
SendSmallTask() : HtcsSignalingTask(TaskType), m_ready_event(os::EventClearMode_ManualClear) { /* ... */ }
|
||||
|
||||
s32 GetHandle() const { return m_handle; }
|
||||
s64 GetSize() const { return m_size; }
|
||||
|
|
@ -354,6 +381,8 @@ namespace ams::htcs::impl::rpc {
|
|||
};
|
||||
|
||||
class SelectTask : public HtcsSignalingTask {
|
||||
public:
|
||||
static constexpr inline HtcsTaskType TaskType = HtcsTaskType::Select;
|
||||
private:
|
||||
s32 m_handles[SocketCountMax * 3];
|
||||
s32 m_read_handle_count;
|
||||
|
|
@ -367,7 +396,7 @@ namespace ams::htcs::impl::rpc {
|
|||
s32 m_out_write_handle_count;
|
||||
s32 m_out_exception_handle_count;
|
||||
public:
|
||||
SelectTask() : HtcsSignalingTask(HtcsTaskType::Select) { /* ... */ }
|
||||
SelectTask() : HtcsSignalingTask(TaskType) { /* ... */ }
|
||||
|
||||
const s32 *GetHandles() const { return m_handles; }
|
||||
s32 GetReadHandleCount() const { return m_read_handle_count; }
|
||||
|
|
|
|||
|
|
@ -79,7 +79,11 @@ namespace ams::htcs::server {
|
|||
auto *manager = impl::HtcsManagerHolder::GetHtcsManager();
|
||||
|
||||
/* Start the select. */
|
||||
return manager->StartSelect(out_task_id.GetPointer(), out_event.GetHandlePointer(), read_handles.ToSpan(), write_handles.ToSpan(), exception_handles.ToSpan(), tv_sec, tv_usec);
|
||||
R_TRY(manager->StartSelect(out_task_id.GetPointer(), out_event.GetHandlePointer(), read_handles.ToSpan(), write_handles.ToSpan(), exception_handles.ToSpan(), tv_sec, tv_usec));
|
||||
|
||||
/* Mark the output event as managed. */
|
||||
out_event.SetManaged(true);
|
||||
return ResultSuccess();
|
||||
}
|
||||
|
||||
Result ManagerServiceObject::EndSelect(sf::Out<s32> out_err, sf::Out<s32> out_count, const sf::OutMapAliasArray<s32> &read_handles, const sf::OutMapAliasArray<s32> &write_handles, const sf::OutMapAliasArray<s32> &exception_handles, u32 task_id) {
|
||||
|
|
|
|||
|
|
@ -118,7 +118,11 @@ namespace ams::htcs::server {
|
|||
auto *manager = impl::HtcsManagerHolder::GetHtcsManager();
|
||||
|
||||
/* Start the accept. */
|
||||
return manager->AcceptStart(out_task_id.GetPointer(), out_event.GetHandlePointer(), m_desc);
|
||||
R_TRY(manager->AcceptStart(out_task_id.GetPointer(), out_event.GetHandlePointer(), m_desc));
|
||||
|
||||
/* Mark the output event as managed. */
|
||||
out_event.SetManaged(true);
|
||||
return ResultSuccess();
|
||||
}
|
||||
|
||||
Result SocketServiceObject::AcceptResults(sf::Out<s32> out_err, sf::Out<sf::SharedPointer<tma::ISocket>> out, sf::Out<htcs::SockAddrHtcs> out_address, u32 task_id) {
|
||||
|
|
@ -143,7 +147,11 @@ namespace ams::htcs::server {
|
|||
auto *manager = impl::HtcsManagerHolder::GetHtcsManager();
|
||||
|
||||
/* Start the recv. */
|
||||
return manager->RecvStart(out_task_id.GetPointer(), out_event.GetHandlePointer(), mem_size, m_desc, flags);
|
||||
R_TRY(manager->RecvStart(out_task_id.GetPointer(), out_event.GetHandlePointer(), mem_size, m_desc, flags));
|
||||
|
||||
/* Mark the output event as managed. */
|
||||
out_event.SetManaged(true);
|
||||
return ResultSuccess();
|
||||
}
|
||||
|
||||
Result SocketServiceObject::RecvResults(sf::Out<s32> out_err, sf::Out<s64> out_size, const sf::OutAutoSelectBuffer &buffer, u32 task_id) {
|
||||
|
|
@ -174,7 +182,11 @@ namespace ams::htcs::server {
|
|||
auto *manager = impl::HtcsManagerHolder::GetHtcsManager();
|
||||
|
||||
/* Start the large receive. */
|
||||
return manager->RecvStart(out_task_id.GetPointer(), out_event.GetHandlePointer(), unaligned_size_start + aligned_size + unaligned_size_end, m_desc, flags);
|
||||
R_TRY(manager->RecvStart(out_task_id.GetPointer(), out_event.GetHandlePointer(), unaligned_size_start + aligned_size + unaligned_size_end, m_desc, flags));
|
||||
|
||||
/* Mark the output event as managed. */
|
||||
out_event.SetManaged(true);
|
||||
return ResultSuccess();
|
||||
}
|
||||
|
||||
Result SocketServiceObject::SendStartOld(sf::Out<u32> out_task_id, sf::OutCopyHandle out_event, const sf::InAutoSelectBuffer &buffer, s32 flags) {
|
||||
|
|
@ -205,7 +217,11 @@ namespace ams::htcs::server {
|
|||
const char *pointers[NumBuffers] = { reinterpret_cast<const char *>(start_buffer.GetPointer()), static_cast<const char *>(address), reinterpret_cast<const char *>(end_buffer.GetPointer()) };
|
||||
s64 sizes[NumBuffers] = { static_cast<s64>(start_buffer.GetSize()), aligned_size, static_cast<s64>(end_buffer.GetSize()) };
|
||||
|
||||
return manager->SendLargeStart(out_task_id.GetPointer(), out_event.GetHandlePointer(), pointers, sizes, NumBuffers, m_desc, flags);
|
||||
R_TRY(manager->SendLargeStart(out_task_id.GetPointer(), out_event.GetHandlePointer(), pointers, sizes, NumBuffers, m_desc, flags));
|
||||
|
||||
/* Mark the output event as managed. */
|
||||
out_event.SetManaged(true);
|
||||
return ResultSuccess();
|
||||
}
|
||||
|
||||
Result SocketServiceObject::SendResults(sf::Out<s32> out_err, sf::Out<s64> out_size, u32 task_id) {
|
||||
|
|
@ -227,6 +243,9 @@ namespace ams::htcs::server {
|
|||
|
||||
/* Set the output max size to the size. */
|
||||
*out_max_size = size;
|
||||
|
||||
/* Mark the output event as managed. */
|
||||
out_event.SetManaged(true);
|
||||
return ResultSuccess();
|
||||
}
|
||||
|
||||
|
|
@ -249,7 +268,11 @@ namespace ams::htcs::server {
|
|||
auto *manager = impl::HtcsManagerHolder::GetHtcsManager();
|
||||
|
||||
/* Start the recv. */
|
||||
return manager->StartRecv(out_task_id.GetPointer(), out_event.GetHandlePointer(), size, m_desc, flags);
|
||||
R_TRY(manager->StartRecv(out_task_id.GetPointer(), out_event.GetHandlePointer(), size, m_desc, flags));
|
||||
|
||||
/* Mark the output event as managed. */
|
||||
out_event.SetManaged(true);
|
||||
return ResultSuccess();
|
||||
}
|
||||
|
||||
Result SocketServiceObject::EndRecv(sf::Out<s32> out_err, sf::Out<s64> out_size, const sf::OutAutoSelectBuffer &buffer, u32 task_id) {
|
||||
|
|
@ -270,7 +293,11 @@ namespace ams::htcs::server {
|
|||
auto *manager = impl::HtcsManagerHolder::GetHtcsManager();
|
||||
|
||||
/* Start the send. */
|
||||
return manager->SendStart(out_task_id.GetPointer(), out_event.GetHandlePointer(), reinterpret_cast<const char *>(buffer.GetPointer()), buffer.GetSize(), m_desc, flags);
|
||||
R_TRY(manager->SendStart(out_task_id.GetPointer(), out_event.GetHandlePointer(), reinterpret_cast<const char *>(buffer.GetPointer()), buffer.GetSize(), m_desc, flags));
|
||||
|
||||
/* Mark the output event as managed. */
|
||||
out_event.SetManaged(true);
|
||||
return ResultSuccess();
|
||||
}
|
||||
|
||||
Result SocketServiceObject::ContinueSend(sf::Out<s64> out_size, sf::Out<bool> out_wait, const sf::InNonSecureAutoSelectBuffer &buffer, u32 task_id) {
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue