The-Homebrew-Cloud/Lime3DS
2
0
Fork 0
mirror of https://github.com/Lime3DS/Lime3DS.git synced 2024-11-23 18:19:21 +01:00
Code Issues Packages Projects Releases Wiki Activity

Fix socket poll and handling in windows (#6166)

Browse Source 
* Fix socket poll and handling in windows

* Fix clang

* Add guest timing adjust

* Use platform independent time fetch

* Use proper type in time_point

* Fix ambiguous function call

* Do suggestions

* Take cpu_clock_scale into account in tick adjust
This commit is contained in:
PabloMK7 2022-10-27 15:05:49 +02:00 committed by GitHub
parent a2daef2985
commit 4d684174e0
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
4 changed files with 227 additions and 52 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
src/core/core_timing.cpp
View File

@ -174,6 +174,22 @@ void Timing::Timer::MoveEvents() {
}
}
u32 Timing::Timer::StartAdjust() {
ASSERT((adjust_value_curr_handle & 1) == 0); // Should always be even
adjust_value_last = std::chrono::steady_clock::now();
return ++adjust_value_curr_handle;
}
void Timing::Timer::EndAdjust(u32 start_adjust_handle) {
std::chrono::time_point<std::chrono::steady_clock> new_timer = std::chrono::steady_clock::now();
ASSERT(new_timer >= adjust_value_last && start_adjust_handle == adjust_value_curr_handle);
AddTicks(nsToCycles(static_cast<float>(
std::chrono::duration_cast<std::chrono::nanoseconds>(new_timer - adjust_value_last)
.count() /
cpu_clock_scale)));
++adjust_value_curr_handle;
}
s64 Timing::Timer::GetMaxSliceLength() const {
const auto& next_event = event_queue.begin();
if (next_event != event_queue.end()) {

8
src/core/core_timing.h
View File

@ -203,6 +203,11 @@ public:
void MoveEvents();
// Use these two functions to adjust the guest system tick on host blocking operations, so
// that the guest can tell how much time passed during the host call.
u32 StartAdjust();
void EndAdjust(u32 start_adjust_handle);
private:
friend class Timing;
// The queue is a min-heap using std::make_heap/push_heap/pop_heap.
@ -227,6 +232,9 @@ public:
s64 downcount = MAX_SLICE_LENGTH;
s64 executed_ticks = 0;
u64 idled_cycles = 0;
std::chrono::time_point<std::chrono::steady_clock> adjust_value_last;
u32 adjust_value_curr_handle = 0;
// Stores a scaling for the internal clockspeed. Changing this number results in
// under/overclocking the guest cpu
double cpu_clock_scale = 1.0;

231
src/core/hle/service/soc_u.cpp
View File

@ -221,19 +221,25 @@ struct CTRPollFD {
/// Translates the resulting events of a Poll operation from 3ds specific to platform
/// specific
static u32 TranslateToPlatform(Events input_event) {
static u32 TranslateToPlatform(Events input_event, bool isOutput) {
#if _WIN32
constexpr bool isWin = true;
#else
constexpr bool isWin = false;
#endif
u32 ret = 0;
if (input_event.pollin)
ret |= POLLIN;
if (input_event.pollpri)
if (input_event.pollpri && !isWin)
ret |= POLLPRI;
if (input_event.pollhup)
if (input_event.pollhup && (!isWin || isOutput))
ret |= POLLHUP;
if (input_event.pollerr)
if (input_event.pollerr && (!isWin || isOutput))
ret |= POLLERR;
if (input_event.pollout)
ret |= POLLOUT;
if (input_event.pollnval)
if (input_event.pollnval && (isWin && isOutput))
ret |= POLLNVAL;
return ret;
}
@ -242,20 +248,26 @@ struct CTRPollFD {
Events revents; ///< Events received (output)
/// Converts a platform-specific pollfd to a 3ds specific structure
static CTRPollFD FromPlatform(pollfd const& fd) {
static CTRPollFD FromPlatform(SOC::SOC_U& socu, pollfd const& fd) {
CTRPollFD result;
result.events.hex = Events::TranslateTo3DS(fd.events).hex;
result.revents.hex = Events::TranslateTo3DS(fd.revents).hex;
result.fd = static_cast<u32>(fd.fd);
for (auto iter = socu.open_sockets.begin(); iter != socu.open_sockets.end(); ++iter) {
if (iter->second.socket_fd == fd.fd) {
result.fd = iter->first;
break;
}
}
return result;
}
/// Converts a 3ds specific pollfd to a platform-specific structure
static pollfd ToPlatform(CTRPollFD const& fd) {
static pollfd ToPlatform(SOC::SOC_U& socu, CTRPollFD const& fd) {
pollfd result;
result.events = Events::TranslateToPlatform(fd.events);
result.revents = Events::TranslateToPlatform(fd.revents);
result.fd = fd.fd;
result.events = Events::TranslateToPlatform(fd.events, false);
result.revents = Events::TranslateToPlatform(fd.revents, true);
auto iter = socu.open_sockets.find(fd.fd);
result.fd = (iter != socu.open_sockets.end()) ? iter->second.socket_fd : 0;
return result;
}
};
@ -351,6 +363,14 @@ struct CTRAddrInfo {
static_assert(sizeof(CTRAddrInfo) == 0x130, "Size of CTRAddrInfo is not correct");
void SOC_U::PreTimerAdjust() {
timer_adjust_handle = Core::System::GetInstance().GetRunningCore().GetTimer().StartAdjust();
}
void SOC_U::PostTimerAdjust() {
Core::System::GetInstance().GetRunningCore().GetTimer().EndAdjust(timer_adjust_handle);
}
void SOC_U::CleanupSockets() {
for (auto sock : open_sockets)
closesocket(sock.second.socket_fd);
@ -385,21 +405,28 @@ void SOC_U::Socket(Kernel::HLERequestContext& ctx) {
return;
}
u32 ret = static_cast<u32>(::socket(domain, type, protocol));
u64 ret = static_cast<u64>(::socket(domain, type, protocol));
u32 socketHandle = GetNextSocketID();
if ((s32)ret != SOCKET_ERROR_VALUE)
open_sockets[ret] = {ret, true};
if ((s64)ret != SOCKET_ERROR_VALUE)
open_sockets[socketHandle] = {static_cast<decltype(SocketHolder::socket_fd)>(ret), true};
if ((s32)ret == SOCKET_ERROR_VALUE)
if ((s64)ret == SOCKET_ERROR_VALUE)
ret = TranslateError(GET_ERRNO);
rb.Push(RESULT_SUCCESS);
rb.Push(ret);
rb.Push(socketHandle);
}
void SOC_U::Bind(Kernel::HLERequestContext& ctx) {
IPC::RequestParser rp(ctx, 0x05, 2, 4);
u32 socket_handle = rp.Pop<u32>();
auto fd_info = open_sockets.find(socket_handle);
if (fd_info == open_sockets.end()) {
IPC::RequestBuilder rb = rp.MakeBuilder(1, 0);
rb.Push(ERR_INVALID_HANDLE);
return;
}
u32 len = rp.Pop<u32>();
rp.PopPID();
auto sock_addr_buf = rp.PopStaticBuffer();
@ -409,7 +436,7 @@ void SOC_U::Bind(Kernel::HLERequestContext& ctx) {
sockaddr sock_addr = CTRSockAddr::ToPlatform(ctr_sock_addr);
s32 ret = ::bind(socket_handle, &sock_addr, std::max<u32>(sizeof(sock_addr), len));
s32 ret = ::bind(fd_info->second.socket_fd, &sock_addr, std::max<u32>(sizeof(sock_addr), len));
if (ret != 0)
ret = TranslateError(GET_ERRNO);
@ -422,6 +449,12 @@ void SOC_U::Bind(Kernel::HLERequestContext& ctx) {
void SOC_U::Fcntl(Kernel::HLERequestContext& ctx) {
IPC::RequestParser rp(ctx, 0x13, 3, 2);
u32 socket_handle = rp.Pop<u32>();
auto fd_info = open_sockets.find(socket_handle);
if (fd_info == open_sockets.end()) {
IPC::RequestBuilder rb = rp.MakeBuilder(1, 0);
rb.Push(ERR_INVALID_HANDLE);
return;
}
u32 ctr_cmd = rp.Pop<u32>();
u32 ctr_arg = rp.Pop<u32>();
rp.PopPID();
@ -436,11 +469,10 @@ void SOC_U::Fcntl(Kernel::HLERequestContext& ctx) {
if (ctr_cmd == 3) { // F_GETFL
#ifdef _WIN32
posix_ret = 0;
auto iter = open_sockets.find(socket_handle);
if (iter != open_sockets.end() && iter->second.blocking == false)
if (fd_info->second.blocking == false)
posix_ret |= 4; // O_NONBLOCK
#else
int ret = ::fcntl(socket_handle, F_GETFL, 0);
int ret = ::fcntl(fd_info->second.socket_fd, F_GETFL, 0);
if (ret == SOCKET_ERROR_VALUE) {
posix_ret = TranslateError(GET_ERRNO);
return;
@ -452,7 +484,7 @@ void SOC_U::Fcntl(Kernel::HLERequestContext& ctx) {
} else if (ctr_cmd == 4) { // F_SETFL
#ifdef _WIN32
unsigned long tmp = (ctr_arg & 4 /* O_NONBLOCK */) ? 1 : 0;
int ret = ioctlsocket(socket_handle, FIONBIO, &tmp);
int ret = ioctlsocket(fd_info->second.socket_fd, FIONBIO, &tmp);
if (ret == SOCKET_ERROR_VALUE) {
posix_ret = TranslateError(GET_ERRNO);
return;
@ -461,7 +493,7 @@ void SOC_U::Fcntl(Kernel::HLERequestContext& ctx) {
if (iter != open_sockets.end())
iter->second.blocking = (tmp == 0);
#else
int flags = ::fcntl(socket_handle, F_GETFL, 0);
int flags = ::fcntl(fd_info->second.socket_fd, F_GETFL, 0);
if (flags == SOCKET_ERROR_VALUE) {
posix_ret = TranslateError(GET_ERRNO);
return;
@ -471,7 +503,7 @@ void SOC_U::Fcntl(Kernel::HLERequestContext& ctx) {
if (ctr_arg & 4) // O_NONBLOCK
flags |= O_NONBLOCK;
int ret = ::fcntl(socket_handle, F_SETFL, flags);
int ret = ::fcntl(fd_info->second.socket_fd, F_SETFL, flags);
if (ret == SOCKET_ERROR_VALUE) {
posix_ret = TranslateError(GET_ERRNO);
return;
@ -487,10 +519,16 @@ void SOC_U::Fcntl(Kernel::HLERequestContext& ctx) {
void SOC_U::Listen(Kernel::HLERequestContext& ctx) {
IPC::RequestParser rp(ctx, 0x03, 2, 2);
u32 socket_handle = rp.Pop<u32>();
auto fd_info = open_sockets.find(socket_handle);
if (fd_info == open_sockets.end()) {
IPC::RequestBuilder rb = rp.MakeBuilder(1, 0);
rb.Push(ERR_INVALID_HANDLE);
return;
}
u32 backlog = rp.Pop<u32>();
rp.PopPID();
s32 ret = ::listen(socket_handle, backlog);
s32 ret = ::listen(fd_info->second.socket_fd, backlog);
if (ret != 0)
ret = TranslateError(GET_ERRNO);
@ -505,11 +543,19 @@ void SOC_U::Accept(Kernel::HLERequestContext& ctx) {
// performing nonblocking operations and spinlock until the data is available
IPC::RequestParser rp(ctx, 0x04, 2, 2);
const auto socket_handle = rp.Pop<u32>();
auto fd_info = open_sockets.find(socket_handle);
if (fd_info == open_sockets.end()) {
IPC::RequestBuilder rb = rp.MakeBuilder(1, 0);
rb.Push(ERR_INVALID_HANDLE);
return;
}
[[maybe_unused]] const auto max_addr_len = static_cast<socklen_t>(rp.Pop<u32>());
rp.PopPID();
sockaddr addr;
socklen_t addr_len = sizeof(addr);
u32 ret = static_cast<u32>(::accept(socket_handle, &addr, &addr_len));
PreTimerAdjust();
u32 ret = static_cast<u32>(::accept(fd_info->second.socket_fd, &addr, &addr_len));
PostTimerAdjust();
if (static_cast<s32>(ret) != SOCKET_ERROR_VALUE) {
open_sockets[ret] = {ret, true};
@ -552,12 +598,21 @@ void SOC_U::GetHostId(Kernel::HLERequestContext& ctx) {
void SOC_U::Close(Kernel::HLERequestContext& ctx) {
IPC::RequestParser rp(ctx, 0x0B, 1, 2);
u32 socket_handle = rp.Pop<u32>();
auto fd_info = open_sockets.find(socket_handle);
if (fd_info == open_sockets.end()) {
IPC::RequestBuilder rb = rp.MakeBuilder(1, 0);
rb.Push(ERR_INVALID_HANDLE);
return;
}
rp.PopPID();
s32 ret = 0;
open_sockets.erase(socket_handle);
ret = closesocket(socket_handle);
PreTimerAdjust();
ret = closesocket(fd_info->second.socket_fd);
PostTimerAdjust();
open_sockets.erase(socket_handle);
if (ret != 0)
ret = TranslateError(GET_ERRNO);
@ -570,6 +625,12 @@ void SOC_U::Close(Kernel::HLERequestContext& ctx) {
void SOC_U::SendTo(Kernel::HLERequestContext& ctx) {
IPC::RequestParser rp(ctx, 0x0A, 4, 6);
u32 socket_handle = rp.Pop<u32>();
auto fd_info = open_sockets.find(socket_handle);
if (fd_info == open_sockets.end()) {
IPC::RequestBuilder rb = rp.MakeBuilder(1, 0);
rb.Push(ERR_INVALID_HANDLE);
return;
}
u32 len = rp.Pop<u32>();
u32 flags = rp.Pop<u32>();
u32 addr_len = rp.Pop<u32>();
@ -578,16 +639,18 @@ void SOC_U::SendTo(Kernel::HLERequestContext& ctx) {
auto dest_addr_buff = rp.PopStaticBuffer();
s32 ret = -1;
PreTimerAdjust();
if (addr_len > 0) {
CTRSockAddr ctr_dest_addr;
std::memcpy(&ctr_dest_addr, dest_addr_buff.data(), sizeof(ctr_dest_addr));
sockaddr dest_addr = CTRSockAddr::ToPlatform(ctr_dest_addr);
ret = ::sendto(socket_handle, reinterpret_cast<const char*>(input_buff.data()), len, flags,
&dest_addr, sizeof(dest_addr));
ret = ::sendto(fd_info->second.socket_fd, reinterpret_cast<const char*>(input_buff.data()),
len, flags, &dest_addr, sizeof(dest_addr));
} else {
ret = ::sendto(socket_handle, reinterpret_cast<const char*>(input_buff.data()), len, flags,
nullptr, 0);
ret = ::sendto(fd_info->second.socket_fd, reinterpret_cast<const char*>(input_buff.data()),
len, flags, nullptr, 0);
}
PostTimerAdjust();
if (ret == SOCKET_ERROR_VALUE)
ret = TranslateError(GET_ERRNO);
@ -600,6 +663,12 @@ void SOC_U::SendTo(Kernel::HLERequestContext& ctx) {
void SOC_U::RecvFromOther(Kernel::HLERequestContext& ctx) {
IPC::RequestParser rp(ctx, 0x7, 4, 4);
u32 socket_handle = rp.Pop<u32>();
auto fd_info = open_sockets.find(socket_handle);
if (fd_info == open_sockets.end()) {
IPC::RequestBuilder rb = rp.MakeBuilder(1, 0);
rb.Push(ERR_INVALID_HANDLE);
return;
}
u32 len = rp.Pop<u32>();
u32 flags = rp.Pop<u32>();
u32 addr_len = rp.Pop<u32>();
@ -613,19 +682,20 @@ void SOC_U::RecvFromOther(Kernel::HLERequestContext& ctx) {
socklen_t src_addr_len = sizeof(src_addr);
s32 ret = -1;
PreTimerAdjust();
if (addr_len > 0) {
ret = ::recvfrom(socket_handle, reinterpret_cast<char*>(output_buff.data()), len, flags,
&src_addr, &src_addr_len);
ret = ::recvfrom(fd_info->second.socket_fd, reinterpret_cast<char*>(output_buff.data()),
len, flags, &src_addr, &src_addr_len);
if (ret >= 0 && src_addr_len > 0) {
ctr_src_addr = CTRSockAddr::FromPlatform(src_addr);
std::memcpy(addr_buff.data(), &ctr_src_addr, sizeof(ctr_src_addr));
}
} else {
ret = ::recvfrom(socket_handle, reinterpret_cast<char*>(output_buff.data()), len, flags,
NULL, 0);
ret = ::recvfrom(fd_info->second.socket_fd, reinterpret_cast<char*>(output_buff.data()),
len, flags, NULL, 0);
addr_buff.resize(0);
}
PostTimerAdjust();
if (ret == SOCKET_ERROR_VALUE) {
ret = TranslateError(GET_ERRNO);
} else {
@ -645,6 +715,12 @@ void SOC_U::RecvFrom(Kernel::HLERequestContext& ctx) {
// performing nonblocking operations and spinlock until the data is available
IPC::RequestParser rp(ctx, 0x08, 4, 2);
u32 socket_handle = rp.Pop<u32>();
auto fd_info = open_sockets.find(socket_handle);
if (fd_info == open_sockets.end()) {
IPC::RequestBuilder rb = rp.MakeBuilder(1, 0);
rb.Push(ERR_INVALID_HANDLE);
return;
}
u32 len = rp.Pop<u32>();
u32 flags = rp.Pop<u32>();
u32 addr_len = rp.Pop<u32>();
@ -657,19 +733,21 @@ void SOC_U::RecvFrom(Kernel::HLERequestContext& ctx) {
socklen_t src_addr_len = sizeof(src_addr);
s32 ret = -1;
PreTimerAdjust();
if (addr_len > 0) {
// Only get src adr if input adr available
ret = ::recvfrom(socket_handle, reinterpret_cast<char*>(output_buff.data()), len, flags,
&src_addr, &src_addr_len);
ret = ::recvfrom(fd_info->second.socket_fd, reinterpret_cast<char*>(output_buff.data()),
len, flags, &src_addr, &src_addr_len);
if (ret >= 0 && src_addr_len > 0) {
ctr_src_addr = CTRSockAddr::FromPlatform(src_addr);
std::memcpy(addr_buff.data(), &ctr_src_addr, sizeof(ctr_src_addr));
}
} else {
ret = ::recvfrom(socket_handle, reinterpret_cast<char*>(output_buff.data()), len, flags,
NULL, 0);
ret = ::recvfrom(fd_info->second.socket_fd, reinterpret_cast<char*>(output_buff.data()),
len, flags, NULL, 0);
addr_buff.resize(0);
}
PostTimerAdjust();
s32 total_received = ret;
if (ret == SOCKET_ERROR_VALUE) {
@ -700,21 +778,32 @@ void SOC_U::Poll(Kernel::HLERequestContext& ctx) {
// The 3ds_pollfd and the pollfd structures may be different (Windows/Linux have different
// sizes)
// so we have to copy the data
// so we have to copy the data in order
std::vector<pollfd> platform_pollfd(nfds);
std::transform(ctr_fds.begin(), ctr_fds.end(), platform_pollfd.begin(), CTRPollFD::ToPlatform);
for (u32 i = 0; i < nfds; i++) {
platform_pollfd[i] = CTRPollFD::ToPlatform(*this, ctr_fds[i]);
}
PreTimerAdjust();
s32 ret = ::poll(platform_pollfd.data(), nfds, timeout);
PostTimerAdjust();
// Now update the output pollfd structure
std::transform(platform_pollfd.begin(), platform_pollfd.end(), ctr_fds.begin(),
CTRPollFD::FromPlatform);
// Now update the output 3ds_pollfd structure
for (u32 i = 0; i < nfds; i++) {
ctr_fds[i] = CTRPollFD::FromPlatform(*this, platform_pollfd[i]);
}
std::vector<u8> output_fds(nfds * sizeof(CTRPollFD));
std::memcpy(output_fds.data(), ctr_fds.data(), nfds * sizeof(CTRPollFD));
if (ret == SOCKET_ERROR_VALUE)
if (ret == SOCKET_ERROR_VALUE) {
int err = GET_ERRNO;
LOG_ERROR(Service_SOC, "Socket error: {}", err);
ret = TranslateError(GET_ERRNO);
}
size_t test = platform_pollfd.size();
IPC::RequestBuilder rb = rp.MakeBuilder(2, 2);
rb.Push(RESULT_SUCCESS);
@ -725,12 +814,18 @@ void SOC_U::Poll(Kernel::HLERequestContext& ctx) {
void SOC_U::GetSockName(Kernel::HLERequestContext& ctx) {
IPC::RequestParser rp(ctx, 0x17, 2, 2);
const auto socket_handle = rp.Pop<u32>();
auto fd_info = open_sockets.find(socket_handle);
if (fd_info == open_sockets.end()) {
IPC::RequestBuilder rb = rp.MakeBuilder(1, 0);
rb.Push(ERR_INVALID_HANDLE);
return;
}
[[maybe_unused]] const auto max_addr_len = rp.Pop<u32>();
rp.PopPID();
sockaddr dest_addr;
socklen_t dest_addr_len = sizeof(dest_addr);
s32 ret = ::getsockname(socket_handle, &dest_addr, &dest_addr_len);
s32 ret = ::getsockname(fd_info->second.socket_fd, &dest_addr, &dest_addr_len);
CTRSockAddr ctr_dest_addr = CTRSockAddr::FromPlatform(dest_addr);
std::vector<u8> dest_addr_buff(sizeof(ctr_dest_addr));
@ -748,10 +843,16 @@ void SOC_U::GetSockName(Kernel::HLERequestContext& ctx) {
void SOC_U::Shutdown(Kernel::HLERequestContext& ctx) {
IPC::RequestParser rp(ctx, 0x0C, 2, 2);
u32 socket_handle = rp.Pop<u32>();
auto fd_info = open_sockets.find(socket_handle);
if (fd_info == open_sockets.end()) {
IPC::RequestBuilder rb = rp.MakeBuilder(1, 0);
rb.Push(ERR_INVALID_HANDLE);
return;
}
s32 how = rp.Pop<s32>();
rp.PopPID();
s32 ret = ::shutdown(socket_handle, how);
s32 ret = ::shutdown(fd_info->second.socket_fd, how);
if (ret != 0)
ret = TranslateError(GET_ERRNO);
IPC::RequestBuilder rb = rp.MakeBuilder(2, 0);
@ -762,12 +863,18 @@ void SOC_U::Shutdown(Kernel::HLERequestContext& ctx) {
void SOC_U::GetPeerName(Kernel::HLERequestContext& ctx) {
IPC::RequestParser rp(ctx, 0x18, 2, 2);
const auto socket_handle = rp.Pop<u32>();
auto fd_info = open_sockets.find(socket_handle);
if (fd_info == open_sockets.end()) {
IPC::RequestBuilder rb = rp.MakeBuilder(1, 0);
rb.Push(ERR_INVALID_HANDLE);
return;
}
[[maybe_unused]] const auto max_addr_len = rp.Pop<u32>();
rp.PopPID();
sockaddr dest_addr;
socklen_t dest_addr_len = sizeof(dest_addr);
const int ret = ::getpeername(socket_handle, &dest_addr, &dest_addr_len);
const int ret = ::getpeername(fd_info->second.socket_fd, &dest_addr, &dest_addr_len);
CTRSockAddr ctr_dest_addr = CTRSockAddr::FromPlatform(dest_addr);
std::vector<u8> dest_addr_buff(sizeof(ctr_dest_addr));
@ -790,6 +897,12 @@ void SOC_U::Connect(Kernel::HLERequestContext& ctx) {
// performing nonblocking operations and spinlock until the data is available
IPC::RequestParser rp(ctx, 0x06, 2, 4);
const auto socket_handle = rp.Pop<u32>();
auto fd_info = open_sockets.find(socket_handle);
if (fd_info == open_sockets.end()) {
IPC::RequestBuilder rb = rp.MakeBuilder(1, 0);
rb.Push(ERR_INVALID_HANDLE);
return;
}
[[maybe_unused]] const auto input_addr_len = rp.Pop<u32>();
rp.PopPID();
auto input_addr_buf = rp.PopStaticBuffer();
@ -798,7 +911,9 @@ void SOC_U::Connect(Kernel::HLERequestContext& ctx) {
std::memcpy(&ctr_input_addr, input_addr_buf.data(), sizeof(ctr_input_addr));
sockaddr input_addr = CTRSockAddr::ToPlatform(ctr_input_addr);
s32 ret = ::connect(socket_handle, &input_addr, sizeof(input_addr));
PreTimerAdjust();
s32 ret = ::connect(fd_info->second.socket_fd, &input_addr, sizeof(input_addr));
PostTimerAdjust();
if (ret != 0)
ret = TranslateError(GET_ERRNO);
@ -830,6 +945,12 @@ void SOC_U::ShutdownSockets(Kernel::HLERequestContext& ctx) {
void SOC_U::GetSockOpt(Kernel::HLERequestContext& ctx) {
IPC::RequestParser rp(ctx, 0x11, 4, 2);
u32 socket_handle = rp.Pop<u32>();
auto fd_info = open_sockets.find(socket_handle);
if (fd_info == open_sockets.end()) {
IPC::RequestBuilder rb = rp.MakeBuilder(1, 0);
rb.Push(ERR_INVALID_HANDLE);
return;
}
u32 level = rp.Pop<u32>();
s32 optname = rp.Pop<s32>();
socklen_t optlen = static_cast<socklen_t>(rp.Pop<u32>());
@ -847,7 +968,7 @@ void SOC_U::GetSockOpt(Kernel::HLERequestContext& ctx) {
#endif
} else {
char* optval_data = reinterpret_cast<char*>(optval.data());
err = ::getsockopt(socket_handle, level, optname, optval_data, &optlen);
err = ::getsockopt(fd_info->second.socket_fd, level, optname, optval_data, &optlen);
if (err == SOCKET_ERROR_VALUE) {
err = TranslateError(GET_ERRNO);
}
@ -863,6 +984,12 @@ void SOC_U::GetSockOpt(Kernel::HLERequestContext& ctx) {
void SOC_U::SetSockOpt(Kernel::HLERequestContext& ctx) {
IPC::RequestParser rp(ctx, 0x12, 4, 4);
const auto socket_handle = rp.Pop<u32>();
auto fd_info = open_sockets.find(socket_handle);
if (fd_info == open_sockets.end()) {
IPC::RequestBuilder rb = rp.MakeBuilder(1, 0);
rb.Push(ERR_INVALID_HANDLE);
return;
}
const auto level = rp.Pop<u32>();
const auto optname = rp.Pop<s32>();
[[maybe_unused]] const auto optlen = static_cast<socklen_t>(rp.Pop<u32>());
@ -879,7 +1006,7 @@ void SOC_U::SetSockOpt(Kernel::HLERequestContext& ctx) {
#endif
} else {
const char* optval_data = reinterpret_cast<const char*>(optval.data());
err = static_cast<u32>(::setsockopt(socket_handle, level, optname, optval_data,
err = static_cast<u32>(::setsockopt(fd_info->second.socket_fd, level, optname, optval_data,
static_cast<socklen_t>(optval.size())));
if (err == SOCKET_ERROR_VALUE) {
err = TranslateError(GET_ERRNO);

24
src/core/hle/service/soc_u.h
View File

@ -6,6 +6,7 @@
#include <unordered_map>
#include <boost/serialization/unordered_map.hpp>
#include "core/hle/result.h"
#include "core/hle/service/service.h"
namespace Core {
@ -16,7 +17,13 @@ namespace Service::SOC {
/// Holds information about a particular socket
struct SocketHolder {
#ifdef _WIN32
using SOCKET = unsigned long long;
SOCKET socket_fd; ///< The socket descriptor
#else
u32 socket_fd; ///< The socket descriptor
#endif // _WIN32
bool blocking; ///< Whether the socket is blocking or not, it is only read on Windows.
private:
@ -34,6 +41,10 @@ public:
~SOC_U();
private:
static constexpr ResultCode ERR_INVALID_HANDLE =
ResultCode(ErrorDescription::InvalidHandle, ErrorModule::SOC, ErrorSummary::InvalidArgument,
ErrorLevel::Permanent);
void Socket(Kernel::HLERequestContext& ctx);
void Bind(Kernel::HLERequestContext& ctx);
void Fcntl(Kernel::HLERequestContext& ctx);
@ -59,16 +70,29 @@ private:
void GetAddrInfoImpl(Kernel::HLERequestContext& ctx);
void GetNameInfoImpl(Kernel::HLERequestContext& ctx);
// Socked ids
u32 next_socket_id = 3;
u32 GetNextSocketID() {
return next_socket_id++;
}
// System timer adjust
u32 timer_adjust_handle;
void PreTimerAdjust();
void PostTimerAdjust();
/// Close all open sockets
void CleanupSockets();
/// Holds info about the currently open sockets
friend struct CTRPollFD;
std::unordered_map<u32, SocketHolder> open_sockets;
template <class Archive>
void serialize(Archive& ar, const unsigned int) {
ar& boost::serialization::base_object<Kernel::SessionRequestHandler>(*this);
ar& open_sockets;
ar& timer_adjust_handle;
}
friend class boost::serialization::access;
};