From 2c19c4658a5af99bd282c934a2ee81204664634d Mon Sep 17 00:00:00 2001 From: lizzie Date: Sat, 15 Aug 2026 20:48:25 +0000 Subject: [PATCH] ALL THE ERROR CODES --- src/core/hle/service/sockets/bsd.cpp | 135 +++++++------- src/core/hle/service/sockets/sfdnsres.cpp | 10 +- src/core/hle/service/ssl/ssl.cpp | 4 +- .../hle/service/ssl/ssl_backend_openssl.cpp | 8 +- .../hle/service/ssl/ssl_backend_schannel.cpp | 8 +- .../ssl/ssl_backend_securetransport.cpp | 4 +- src/core/internal_network/network.cpp | 107 +++++------ src/core/internal_network/socket_icmp.cpp | 42 ++--- src/core/internal_network/socket_proxy.cpp | 44 ++--- src/core/internal_network/socket_types.h | 166 ++++++++++++++---- src/tests/core/internal_network/network.cpp | 6 +- 11 files changed, 318 insertions(+), 216 deletions(-) diff --git a/src/core/hle/service/sockets/bsd.cpp b/src/core/hle/service/sockets/bsd.cpp index e5b53b653a..13b2e7ec21 100644 --- a/src/core/hle/service/sockets/bsd.cpp +++ b/src/core/hle/service/sockets/bsd.cpp @@ -31,14 +31,15 @@ namespace Service::Sockets { namespace { -bool IsConnectionBased(Network::Type type) { +[[nodiscard]] bool IsConnectionBased(Network::Type type) noexcept { switch (type) { case Network::Type::STREAM: + case Network::Type::SEQPACKET: + case Network::Type::RAW: return true; case Network::Type::DGRAM: - return false; - default: - UNIMPLEMENTED_MSG("Unimplemented type={}", type); + case Network::Type::RDM: + case Network::Type::Unspecified: return false; } } @@ -95,7 +96,7 @@ void BSD::ConnectWork::Execute(BSD* bsd) { void BSD::ConnectWork::Response(HLERequestContext& ctx) { IPC::ResponseBuilder rb{ctx, 4}; rb.Push(ResultSuccess); - rb.Push(bsd_errno == Network::Errno::SUCCESS ? 0 : -1); + rb.Push(bsd_errno == Network::Errno::E_SUCCESS ? 0 : -1); rb.PushEnum(bsd_errno); } @@ -272,7 +273,7 @@ void BSD::GetPeerName(HLERequestContext& ctx) { IPC::ResponseBuilder rb{ctx, 5}; rb.Push(ResultSuccess); - rb.Push(bsd_errno != Network::Errno::SUCCESS ? -1 : 0); + rb.Push(bsd_errno != Network::Errno::E_SUCCESS ? -1 : 0); rb.PushEnum(bsd_errno); rb.Push(static_cast(write_buffer.size())); } @@ -290,7 +291,7 @@ void BSD::GetSockName(HLERequestContext& ctx) { IPC::ResponseBuilder rb{ctx, 5}; rb.Push(ResultSuccess); - rb.Push(bsd_errno != Network::Errno::SUCCESS ? -1 : 0); + rb.Push(bsd_errno != Network::Errno::E_SUCCESS ? -1 : 0); rb.PushEnum(bsd_errno); rb.Push(static_cast(write_buffer.size())); } @@ -310,7 +311,7 @@ void BSD::GetSockOpt(HLERequestContext& ctx) { IPC::ResponseBuilder rb{ctx, 5}; rb.Push(ResultSuccess); - rb.Push(err == Network::Errno::SUCCESS ? 0 : -1); + rb.Push(err == Network::Errno::E_SUCCESS ? 0 : -1); rb.PushEnum(err); rb.Push(static_cast(optval.size())); } @@ -492,7 +493,7 @@ void BSD::DuplicateSocket(HLERequestContext& ctx) { if (auto* res = std::get_if(&res_v)) { rb.PushRaw(OutputParameters{ .ret = *res, - .bsd_errno = Network::Errno::SUCCESS, + .bsd_errno = Network::Errno::E_SUCCESS, }); } else { auto* err = std::get_if(&res_v); @@ -510,7 +511,7 @@ void BSD::EventFd(HLERequestContext& ctx) { LOG_WARNING(Service, "(STUBBED) called. initval={}, flags={}", initval, flags); - BuildErrnoResponse(ctx, Network::Errno::SUCCESS); + BuildErrnoResponse(ctx, Network::Errno::E_SUCCESS); } template @@ -526,7 +527,7 @@ std::pair BSD::SocketImpl(Network::Domain domain, Network:: if (type == Network::Type::RAW && domain == Network::Domain::INET && protocol == Network::Protocol::ICMP) { // fine, can use on bsd:s and bsd:u } else { - return {-1, Network::Errno::INVAL}; + return {-1, Network::Errno::E_INVAL}; } } @@ -537,13 +538,13 @@ std::pair BSD::SocketImpl(Network::Domain domain, Network:: const s32 fd = FindFreeFileDescriptorHandle(); if (fd < 0) { LOG_ERROR(Service, "No more file descriptors available"); - return {-1, Network::Errno::MFILE}; + return {-1, Network::Errno::E_MFILE}; } if (Settings::values.airplane_mode.GetValue() && IsConnectionBased(type)) { LOG_ERROR(Service, "Airplane mode is enabled, cannot create socket"); file_descriptors[fd].reset(); - return {-1, Network::Errno::NOTCONN}; + return {-1, Network::Errno::E_NOTCONN}; } file_descriptors[fd] = FileDescriptor{}; @@ -566,7 +567,7 @@ std::pair BSD::SocketImpl(Network::Domain domain, Network:: #if defined(__unix__) && !defined(__APPLE__) // ...only unix has this issue it seems, ICMP works otherwise fine on win - if (bsd_errno != Network::Errno::SUCCESS + if (bsd_errno != Network::Errno::E_SUCCESS && (protocol == Network::Protocol::ICMP || protocol == Network::Protocol::ICMPV6)) { LOG_WARNING(Network, "Using ICMP emulated socket"); descriptor.socket = std::make_shared(); @@ -582,20 +583,20 @@ std::pair BSD::SocketImpl(Network::Domain domain, Network:: file_descriptors[fd].reset(); return {-1, bsd_errno}; } - return {fd, Network::Errno::SUCCESS}; + return {fd, Network::Errno::E_SUCCESS}; } std::pair BSD::PollImpl(std::vector& write_buffer, std::span read_buffer, s32 nfds, s32 timeout) { LOG_DEBUG(Network, "nfds={},timeout={}", nfds, timeout); if (nfds <= 0) { // When no entries are provided, -1 is returned with errno zero - return {-1, Network::Errno::SUCCESS}; + return {-1, Network::Errno::E_SUCCESS}; } if (read_buffer.size() < nfds * sizeof(Network::PollFD)) { - return {-1, Network::Errno::INVAL}; + return {-1, Network::Errno::E_INVAL}; } if (write_buffer.size() < nfds * sizeof(Network::PollFD)) { - return {-1, Network::Errno::INVAL}; + return {-1, Network::Errno::E_INVAL}; } std::span in_fds(reinterpret_cast(read_buffer.data()), nfds); @@ -606,13 +607,13 @@ std::pair BSD::PollImpl(std::vector& write_buffer, std: const s64 seconds = timeout / 1000; const u64 nanoseconds = 1'000'000 * (u64(timeout) % 1000); if (seconds < 0) { - return {-1, Network::Errno::INVAL}; + return {-1, Network::Errno::E_INVAL}; } if (nanoseconds > 999'999'999) { - return {-1, Network::Errno::INVAL}; + return {-1, Network::Errno::E_INVAL}; } } else if (timeout != -1) { - return {-1, Network::Errno::INVAL}; + return {-1, Network::Errno::E_INVAL}; } for (size_t i = 0; i < in_fds.size(); ++i) { @@ -621,7 +622,7 @@ std::pair BSD::PollImpl(std::vector& write_buffer, std: out_fds[i].revents = {}; if (!file_descriptors[in_fds[i].fd]) out_fds[i].revents = Network::PollEvents::NVAL; - return {0, Network::Errno::SUCCESS}; + return {0, Network::Errno::E_SUCCESS}; } } @@ -642,18 +643,18 @@ std::pair BSD::PollImpl(std::vector& write_buffer, std: std::pair BSD::AcceptImpl(s32 fd, std::vector& write_buffer) { LOG_DEBUG(Network, "fd={}", fd); if (!IsFileDescriptorValid(fd)) { - return {-1, Network::Errno::BADF}; + return {-1, Network::Errno::E_BADF}; } const s32 new_fd = FindFreeFileDescriptorHandle(); if (new_fd < 0) { LOG_ERROR(Service, "No more file descriptors available"); - return {-1, Network::Errno::MFILE}; + return {-1, Network::Errno::E_MFILE}; } FileDescriptor& descriptor = *file_descriptors[fd]; auto [result, bsd_errno] = descriptor.socket->Accept(); - if (bsd_errno != Network::Errno::SUCCESS) { + if (bsd_errno != Network::Errno::E_SUCCESS) { return {-1, bsd_errno}; } @@ -663,18 +664,18 @@ std::pair BSD::AcceptImpl(s32 fd, std::vector& write_bu new_descriptor.is_connection_based = descriptor.is_connection_based; PutValue(write_buffer, result.sockaddr_in); - return {new_fd, Network::Errno::SUCCESS}; + return {new_fd, Network::Errno::E_SUCCESS}; } Network::Errno BSD::BindImpl(s32 fd, std::span addr) { LOG_DEBUG(Network, "fd={}", fd); if (!IsFileDescriptorValid(fd)) { - return Network::Errno::BADF; + return Network::Errno::E_BADF; } ASSERT(addr.size() >= 16); if (!file_descriptors[fd]->socket) { LOG_WARNING(Service, "Uninitialized socket"); - return Network::Errno::BADF; + return Network::Errno::E_BADF; } auto addr_in = GetValue(addr); @@ -684,20 +685,20 @@ Network::Errno BSD::BindImpl(s32 fd, std::span addr) { Network::Errno BSD::ConnectImpl(s32 fd, std::span addr) { LOG_DEBUG(Network, "fd={}", fd); if (!IsFileDescriptorValid(fd)) { - return Network::Errno::BADF; + return Network::Errno::E_BADF; } ASSERT(addr.size() >= 16); if (!file_descriptors[fd]->socket) { LOG_WARNING(Service, "Uninitialized socket"); - return Network::Errno::BADF; + return Network::Errno::E_BADF; } auto addr_in = GetValue(addr); const Network::Errno result = file_descriptors[fd]->socket->Connect(addr_in); - if (result == Network::Errno::ISCONN) { + if (result == Network::Errno::E_ISCONN) { LOG_DEBUG(Service, "returned ISCONN - socket already connected"); - return Network::Errno::SUCCESS; + return Network::Errno::E_SUCCESS; } return result; @@ -706,16 +707,16 @@ Network::Errno BSD::ConnectImpl(s32 fd, std::span addr) { Network::Errno BSD::GetPeerNameImpl(s32 fd, std::vector& write_buffer) { LOG_DEBUG(Network, "fd={}", fd); if (!IsFileDescriptorValid(fd)) { - return Network::Errno::BADF; + return Network::Errno::E_BADF; } if (!file_descriptors[fd]->socket) { LOG_WARNING(Service, "Uninitialized socket"); - return Network::Errno::BADF; + return Network::Errno::E_BADF; } const auto [addr_in, bsd_errno] = file_descriptors[fd]->socket->GetPeerName(); - if (bsd_errno != Network::Errno::SUCCESS) { + if (bsd_errno != Network::Errno::E_SUCCESS) { return bsd_errno; } ASSERT(write_buffer.size() >= addr_in.len); @@ -727,16 +728,16 @@ Network::Errno BSD::GetPeerNameImpl(s32 fd, std::vector& write_buffer) { Network::Errno BSD::GetSockNameImpl(s32 fd, std::vector& write_buffer) { LOG_DEBUG(Network, "fd={}", fd); if (!IsFileDescriptorValid(fd)) { - return Network::Errno::BADF; + return Network::Errno::E_BADF; } if (!file_descriptors[fd]->socket) { LOG_WARNING(Service, "Uninitialized socket"); - return Network::Errno::BADF; + return Network::Errno::E_BADF; } const auto [addr_in, bsd_errno] = file_descriptors[fd]->socket->GetSockName(); - if (bsd_errno != Network::Errno::SUCCESS) { + if (bsd_errno != Network::Errno::E_SUCCESS) { return bsd_errno; } ASSERT(write_buffer.size() >= addr_in.len); @@ -748,11 +749,11 @@ Network::Errno BSD::GetSockNameImpl(s32 fd, std::vector& write_buffer) { Network::Errno BSD::ListenImpl(s32 fd, s32 backlog) { LOG_DEBUG(Network, "fd={},backlog={}", fd, backlog); if (!IsFileDescriptorValid(fd)) { - return Network::Errno::BADF; + return Network::Errno::E_BADF; } if (!file_descriptors[fd]->socket) { LOG_WARNING(Service, "Uninitialized socket"); - return Network::Errno::BADF; + return Network::Errno::E_BADF; } return file_descriptors[fd]->socket->Listen(backlog); } @@ -760,41 +761,41 @@ Network::Errno BSD::ListenImpl(s32 fd, s32 backlog) { std::pair BSD::FcntlImpl(s32 fd, Network::FcntlCmd cmd, s32 arg) { LOG_DEBUG(Network, "fd={},cmd={},arg={}", fd, u32(cmd), arg); if (!IsFileDescriptorValid(fd)) { - return {-1, Network::Errno::BADF}; + return {-1, Network::Errno::E_BADF}; } if (!file_descriptors[fd]->socket) { LOG_WARNING(Service, "Uninitialized socket"); - return {-1, Network::Errno::BADF}; + return {-1, Network::Errno::E_BADF}; } FileDescriptor& descriptor = *file_descriptors[fd]; switch (cmd) { case Network::FcntlCmd::GETFL: ASSERT(arg == 0); - return {descriptor.flags, Network::Errno::SUCCESS}; + return {descriptor.flags, Network::Errno::E_SUCCESS}; case Network::FcntlCmd::SETFL: { const bool enable = (arg & u32(Network::FcntlFlags::NONBLOCK_NX)) != 0; const Network::Errno bsd_errno = descriptor.socket->SetNonBlock(enable); - if (bsd_errno != Network::Errno::SUCCESS) { + if (bsd_errno != Network::Errno::E_SUCCESS) { return {-1, bsd_errno}; } descriptor.flags = arg; - return {0, Network::Errno::SUCCESS}; + return {0, Network::Errno::E_SUCCESS}; } default: UNIMPLEMENTED_MSG("Unimplemented cmd={}", cmd); - return {-1, Network::Errno::SUCCESS}; + return {-1, Network::Errno::E_SUCCESS}; } } Network::Errno BSD::GetSockOptImpl(s32 fd, Network::SocketLevel level, Network::OptName optname, std::vector& optval) { LOG_DEBUG(Network, "fd={},level={},optname={}", fd, u32(level), u32(optname)); if (!IsFileDescriptorValid(fd)) { - return Network::Errno::BADF; + return Network::Errno::E_BADF; } if (!file_descriptors[fd]->socket) { LOG_WARNING(Service, "Uninitialized socket"); - return Network::Errno::BADF; + return Network::Errno::E_BADF; } if (level != Network::SocketLevel::SOCKET) { @@ -806,9 +807,9 @@ Network::Errno BSD::GetSockOptImpl(s32 fd, Network::SocketLevel level, Network:: switch (optname) { case Network::OptName::ERROR_: { auto [pending_err, getsockopt_err] = socket->GetPendingError(); - if (getsockopt_err == Network::Errno::SUCCESS) { + if (getsockopt_err == Network::Errno::E_SUCCESS) { ASSERT_OR_EXECUTE_MSG( - optval.size() == sizeof(Network::Errno), { return Network::Errno::INVAL; }, + optval.size() == sizeof(Network::Errno), { return Network::Errno::E_INVAL; }, "Incorrect getsockopt option size"); optval.resize(sizeof(Network::Errno)); PutValue(optval, pending_err); @@ -817,18 +818,18 @@ Network::Errno BSD::GetSockOptImpl(s32 fd, Network::SocketLevel level, Network:: } default: UNIMPLEMENTED_MSG("Unimplemented optname={}", optname); - return Network::Errno::SUCCESS; + return Network::Errno::E_SUCCESS; } } Network::Errno BSD::SetSockOptImpl(s32 fd, Network::SocketLevel level, Network::OptName optname, std::span optval) { LOG_DEBUG(Service, "fd={},level={},optname={}", fd, level, optname); if (!IsFileDescriptorValid(fd)) { - return Network::Errno::BADF; + return Network::Errno::E_BADF; } if (!file_descriptors[fd]->socket) { LOG_WARNING(Service, "Uninitialized socket"); - return Network::Errno::BADF; + return Network::Errno::E_BADF; } Network::SocketBase* const socket = file_descriptors[fd]->socket.get(); @@ -838,11 +839,11 @@ Network::Errno BSD::SetSockOptImpl(s32 fd, Network::SocketLevel level, Network:: Network::Errno BSD::ShutdownImpl(s32 fd, s32 how) { LOG_DEBUG(Network, "fd={},how={}", fd, how); if (!IsFileDescriptorValid(fd)) { - return Network::Errno::BADF; + return Network::Errno::E_BADF; } if (!file_descriptors[fd]->socket) { LOG_WARNING(Service, "Uninitialized socket"); - return Network::Errno::BADF; + return Network::Errno::E_BADF; } return file_descriptors[fd]->socket->Shutdown(Network::ShutdownHow(how)); } @@ -850,7 +851,7 @@ Network::Errno BSD::ShutdownImpl(s32 fd, s32 how) { std::pair BSD::RecvImpl(s32 fd, u32 flags, std::vector& message) { LOG_DEBUG(Network, "fd={},flags={}", fd, flags); if (!IsFileDescriptorValid(fd)) { - return {-1, Network::Errno::BADF}; + return {-1, Network::Errno::E_BADF}; } FileDescriptor& descriptor = *file_descriptors[fd]; @@ -873,7 +874,7 @@ std::pair BSD::RecvImpl(s32 fd, u32 flags, std::vector& std::pair BSD::RecvFromImpl(s32 fd, u32 flags, std::vector& message, std::vector& addr) { LOG_DEBUG(Network, "fd={},flags={}", fd, flags); if (!IsFileDescriptorValid(fd)) { - return {-1, Network::Errno::BADF}; + return {-1, Network::Errno::E_BADF}; } FileDescriptor& descriptor = *file_descriptors[fd]; @@ -917,11 +918,11 @@ std::pair BSD::RecvFromImpl(s32 fd, u32 flags, std::vector< std::pair BSD::SendImpl(s32 fd, u32 flags, std::span message) { LOG_DEBUG(Network, "fd={},flags={}", fd, flags); if (!IsFileDescriptorValid(fd)) { - return {-1, Network::Errno::BADF}; + return {-1, Network::Errno::E_BADF}; } if (!file_descriptors[fd]->socket) { LOG_WARNING(Service, "Uninitialized socket"); - return {-1, Network::Errno::BADF}; + return {-1, Network::Errno::E_BADF}; } return file_descriptors[fd]->socket->Send(message, flags); } @@ -929,11 +930,11 @@ std::pair BSD::SendImpl(s32 fd, u32 flags, std::span BSD::SendToImpl(s32 fd, u32 flags, std::span message, std::span addr) { LOG_DEBUG(Network, "fd={},flags={}", fd, flags); if (!IsFileDescriptorValid(fd)) { - return {-1, Network::Errno::BADF}; + return {-1, Network::Errno::E_BADF}; } if (!file_descriptors[fd]->socket) { LOG_WARNING(Service, "Uninitialized socket"); - return {-1, Network::Errno::BADF}; + return {-1, Network::Errno::E_BADF}; } Network::SockAddrIn addr_in{}; @@ -951,15 +952,15 @@ std::pair BSD::SendToImpl(s32 fd, u32 flags, std::spansocket) { LOG_WARNING(Service, "Uninitialized socket"); - return Network::Errno::BADF; + return Network::Errno::E_BADF; } auto const bsd_errno = file_descriptors[fd]->socket->Close(); - if (bsd_errno != Network::Errno::SUCCESS) { + if (bsd_errno != Network::Errno::E_SUCCESS) { return bsd_errno; } @@ -972,13 +973,13 @@ Network::Errno BSD::CloseImpl(s32 fd) { std::variant BSD::DuplicateSocketImpl(s32 fd) { LOG_DEBUG(Network, "fd={}", fd); if (!IsFileDescriptorValid(fd)) { - return Network::Errno::BADF; + return Network::Errno::E_BADF; } const s32 new_fd = FindFreeFileDescriptorHandle(); if (!IsFileDescriptorValid(new_fd)) { LOG_ERROR(Service, "No more file descriptors available"); - return Network::Errno::MFILE; + return Network::Errno::E_MFILE; } file_descriptors[new_fd] = FileDescriptor{ @@ -1026,7 +1027,7 @@ void BSD::BuildErrnoResponse(HLERequestContext& ctx, Network::Errno bsd_errno) c IPC::ResponseBuilder rb{ctx, 4}; rb.Push(ResultSuccess); - rb.Push(bsd_errno == Network::Errno::SUCCESS ? 0 : -1); + rb.Push(bsd_errno == Network::Errno::E_SUCCESS ? 0 : -1); rb.PushEnum(bsd_errno); } diff --git a/src/core/hle/service/sockets/sfdnsres.cpp b/src/core/hle/service/sockets/sfdnsres.cpp index d520fbc1e2..8837fcd8c0 100644 --- a/src/core/hle/service/sockets/sfdnsres.cpp +++ b/src/core/hle/service/sockets/sfdnsres.cpp @@ -126,15 +126,15 @@ static Network::Errno GetAddrInfoErrorToErrno(Network::GetAddrInfoError result) case Network::GetAddrInfoError::SUCCESS: // Note: Sometimes a successful lookup sets errno to EADDRNOTAVAIL for // some reason, but that doesn't seem useful to implement. - return Network::Errno::SUCCESS; + return Network::Errno::E_SUCCESS; case Network::GetAddrInfoError::AGAIN: - return Network::Errno::SUCCESS; + return Network::Errno::E_SUCCESS; case Network::GetAddrInfoError::NODATA: - return Network::Errno::SUCCESS; + return Network::Errno::E_SUCCESS; case Network::GetAddrInfoError::SERVICE: - return Network::Errno::INVAL; + return Network::Errno::E_INVAL; default: - return Network::Errno::SUCCESS; + return Network::Errno::E_SUCCESS; } } diff --git a/src/core/hle/service/ssl/ssl.cpp b/src/core/hle/service/ssl/ssl.cpp index 87e438b81c..c34d82ae66 100644 --- a/src/core/hle/service/ssl/ssl.cpp +++ b/src/core/hle/service/ssl/ssl.cpp @@ -132,7 +132,7 @@ public: auto bsd = system.ServiceManager().GetService("bsd:u"); if (bsd) { auto err = bsd->CloseImpl(fd); - if (err != Network::Errno::SUCCESS) { + if (err != Network::Errno::E_SUCCESS) { LOG_ERROR(Service_SSL, "Failed to close duplicated socket: {}", err); } } @@ -203,7 +203,7 @@ private: const bool non_block = mode == IoMode::NonBlocking; const Network::Errno error = socket->SetNonBlock(non_block); - if (error != Network::Errno::SUCCESS) { + if (error != Network::Errno::E_SUCCESS) { LOG_ERROR(Service_SSL, "Failed to set native socket non-block flag to {}", non_block); } return ResultSuccess; diff --git a/src/core/hle/service/ssl/ssl_backend_openssl.cpp b/src/core/hle/service/ssl/ssl_backend_openssl.cpp index f0e05266ba..99ad620bf1 100644 --- a/src/core/hle/service/ssl/ssl_backend_openssl.cpp +++ b/src/core/hle/service/ssl/ssl_backend_openssl.cpp @@ -290,10 +290,10 @@ public: BIO_clear_retry_flags(bio); auto [actual, err] = self->socket->Send({reinterpret_cast(buf), len}, 0); switch (err) { - case Network::Errno::SUCCESS: + case Network::Errno::E_SUCCESS: *actual_p = actual; return 1; - case Network::Errno::AGAIN: + case Network::Errno::E_AGAIN: BIO_set_flags(bio, BIO_FLAGS_WRITE | BIO_FLAGS_SHOULD_RETRY); return 0; default: @@ -309,13 +309,13 @@ public: BIO_clear_retry_flags(bio); auto [actual, err] = self->socket->Recv(0, {reinterpret_cast(buf), len}); switch (err) { - case Network::Errno::SUCCESS: + case Network::Errno::E_SUCCESS: *actual_p = actual; if (actual == 0) { self->got_read_eof = true; } return actual ? 1 : 0; - case Network::Errno::AGAIN: + case Network::Errno::E_AGAIN: BIO_set_flags(bio, BIO_FLAGS_READ | BIO_FLAGS_SHOULD_RETRY); return 0; default: diff --git a/src/core/hle/service/ssl/ssl_backend_schannel.cpp b/src/core/hle/service/ssl/ssl_backend_schannel.cpp index 2b68f29eaf..3cd37c9d90 100644 --- a/src/core/hle/service/ssl/ssl_backend_schannel.cpp +++ b/src/core/hle/service/ssl/ssl_backend_schannel.cpp @@ -146,11 +146,11 @@ public: const auto read_span = std::span(ciphertext_read_buf).subspan(offset, fill_size); const auto [actual, err] = socket->Recv(0, read_span); switch (err) { - case Network::Errno::SUCCESS: + case Network::Errno::E_SUCCESS: ASSERT(static_cast(actual) <= fill_size); ciphertext_read_buf.resize(offset + actual); return ResultSuccess; - case Network::Errno::AGAIN: + case Network::Errno::E_AGAIN: ciphertext_read_buf.resize(offset); return ResultWouldBlock; default: @@ -165,12 +165,12 @@ public: while (!ciphertext_write_buf.empty()) { const auto [actual, err] = socket->Send(ciphertext_write_buf, 0); switch (err) { - case Network::Errno::SUCCESS: + case Network::Errno::E_SUCCESS: ASSERT(static_cast(actual) <= ciphertext_write_buf.size()); ciphertext_write_buf.erase(ciphertext_write_buf.begin(), ciphertext_write_buf.begin() + actual); break; - case Network::Errno::AGAIN: + case Network::Errno::E_AGAIN: return ResultWouldBlock; default: LOG_ERROR(Service_SSL, "Socket send returned Network::Errno {}", err); diff --git a/src/core/hle/service/ssl/ssl_backend_securetransport.cpp b/src/core/hle/service/ssl/ssl_backend_securetransport.cpp index 65f81be631..ccffdca9ee 100644 --- a/src/core/hle/service/ssl/ssl_backend_securetransport.cpp +++ b/src/core/hle/service/ssl/ssl_backend_securetransport.cpp @@ -195,7 +195,7 @@ public: LOG_CRITICAL(Service_SSL, "op={}, offset={} actual={}/{} err={}", is_read, offset, actual, cur.size(), static_cast(err)); switch (err) { - case Network::Errno::SUCCESS: + case Network::Errno::E_SUCCESS: offset += actual; if (actual == 0) { ASSERT(is_read); @@ -203,7 +203,7 @@ public: return errSecEndOfData; } break; - case Network::Errno::AGAIN: + case Network::Errno::E_AGAIN: *dataLength = offset; return errSSLWouldBlock; default: diff --git a/src/core/internal_network/network.cpp b/src/core/internal_network/network.cpp index a026d4c563..de735ae937 100644 --- a/src/core/internal_network/network.cpp +++ b/src/core/internal_network/network.cpp @@ -92,42 +92,42 @@ LINGER MakeLinger(bool enable, u32 linger_value) { Errno TranslateNativeError(int e, CallType call_type = CallType::Other) { switch (e) { - case 0: return Errno::SUCCESS; + case 0: return Errno::E_SUCCESS; case WSAECONNABORTED: if (call_type == CallType::Send) { // Winsock yields WSAECONNABORTED from `send` in situations where Unix // systems, and actual Switches, yield EPIPE. - return Errno::PIPE; + return Errno::E_PIPE; } else { - return Errno::CONNABORTED; + return Errno::E_CONNABORTED; } - case WSAEBADF: return Errno::BADF; - case WSAEINVAL: return Errno::INVAL; - case WSAEMFILE: return Errno::MFILE; - case WSAENOTCONN: return Errno::NOTCONN; - case WSAEWOULDBLOCK: return Errno::AGAIN; - case WSAECONNREFUSED: return Errno::CONNREFUSED; - case WSAECONNRESET: return Errno::CONNRESET; - case WSAEHOSTUNREACH: return Errno::HOSTUNREACH; - case WSAENETDOWN: return Errno::NETDOWN; - case WSAENETUNREACH: return Errno::NETUNREACH; - case WSAEMSGSIZE: return Errno::MSGSIZE; - case WSAETIMEDOUT: return Errno::TIMEDOUT; - case WSAEINPROGRESS: return Errno::INPROGRESS; - case WSAEISCONN: return Errno::ISCONN; - case WSAEADDRINUSE: return Errno::ADDRINUSE; - case WSAEADDRNOTAVAIL: return Errno::ADDRNOTAVAIL; - case WSAEPROTOTYPE: return Errno::PROTOTYPE; - case WSAENOPROTOOPT: return Errno::NOPROTOOPT; - case WSAEPROTONOSUPPORT: return Errno::PROTONOSUPPORT; - case WSAESOCKTNOSUPPORT: return Errno::SOCKTNOSUPPORT; + case WSAEBADF: return Errno::E_BADF; + case WSAEINVAL: return Errno::E_INVAL; + case WSAEMFILE: return Errno::E_MFILE; + case WSAENOTCONN: return Errno::E_NOTCONN; + case WSAEWOULDBLOCK: return Errno::E_AGAIN; + case WSAECONNREFUSED: return Errno::E_CONNREFUSED; + case WSAECONNRESET: return Errno::E_CONNRESET; + case WSAEHOSTUNREACH: return Errno::E_HOSTUNREACH; + case WSAENETDOWN: return Errno::E_NETDOWN; + case WSAENETUNREACH: return Errno::E_NETUNREACH; + case WSAEMSGSIZE: return Errno::E_MSGSIZE; + case WSAETIMEDOUT: return Errno::E_TIMEDOUT; + case WSAEINPROGRESS: return Errno::E_INPROGRESS; + case WSAEISCONN: return Errno::E_ISCONN; + case WSAEADDRINUSE: return Errno::E_ADDRINUSE; + case WSAEADDRNOTAVAIL: return Errno::E_ADDRNOTAVAIL; + case WSAEPROTOTYPE: return Errno::E_PROTOTYPE; + case WSAENOPROTOOPT: return Errno::E_NOPROTOOPT; + case WSAEPROTONOSUPPORT: return Errno::E_PROTONOSUPPORT; + case WSAESOCKTNOSUPPORT: return Errno::E_SOCKTNOSUPPORT; #ifdef WSAENOTSUP // Not defined by fucking MSVC because MSVC is stupid as shitfuckery - case WSAENOTSUP: return Errno::NOTSUP; + case WSAENOTSUP: return Errno::E_NOTSUP; #endif default: UNIMPLEMENTED_MSG("Unimplemented errno={}", e); - return Errno::OTHER; + return Errno::E_OTHER; } } @@ -210,7 +210,7 @@ linger MakeLinger(bool enable, u32 linger_value) { Errno TranslateNativeError(int e, CallType call_type = CallType::Other) { switch (e) { - case 0: return Errno::SUCCESS; + case 0: return Errno::E_SUCCESS; #define NETWORK_ERROR_LIST \ NETWORK_ERROR_ELEM(NOENT) \ NETWORK_ERROR_ELEM(INTR) \ @@ -234,6 +234,7 @@ Errno TranslateNativeError(int e, CallType call_type = CallType::Other) { NETWORK_ERROR_ELEM(ISCONN) \ NETWORK_ERROR_ELEM(PROTOTYPE) \ NETWORK_ERROR_ELEM(NOPROTOOPT) \ + NETWORK_ERROR_ELEM(AFNOSUPPORT) \ NETWORK_ERROR_ELEM(PROTONOSUPPORT) \ NETWORK_ERROR_ELEM(SOCKTNOSUPPORT) \ NETWORK_ERROR_ELEM(NOTSUP) \ @@ -242,13 +243,13 @@ Errno TranslateNativeError(int e, CallType call_type = CallType::Other) { NETWORK_ERROR_ELEM(NOTSOCK) \ NETWORK_ERROR_ELEM(ALREADY) \ NETWORK_ERROR_ELEM(STALE) -#define NETWORK_ERROR_ELEM(name) case E##name: return Errno::name; +#define NETWORK_ERROR_ELEM(name) case E##name: return Errno::E_##name; NETWORK_ERROR_LIST #undef NETWORK_ERROR_ELEM #undef NETWORK_ERROR_LIST default: UNIMPLEMENTED_MSG("Unimplemented errno={} ({})", e, strerror(e)); - return Errno::OTHER; + return Errno::E_OTHER; } } @@ -261,7 +262,7 @@ Errno GetAndLogLastError(CallType call_type) { int e = errno; #endif const Errno err = TranslateNativeError(e, call_type); - if (err == Errno::AGAIN || err == Errno::TIMEDOUT || err == Errno::INPROGRESS) { + if (err == Errno::E_AGAIN || err == Errno::E_TIMEDOUT || err == Errno::E_INPROGRESS) { // These happen during normal operation, so only log them at debug level. LOG_DEBUG(Network, "Socket operation error: {}", Common::NativeErrorToString(e)); return err; @@ -909,7 +910,7 @@ std::pair Poll(std::span pollfds, s32 timeout) { ASSERT(std::all_of(host_pollfds.begin(), host_pollfds.end(), [](auto const fd) { return fd.revents == 0; })); - return {0, Errno::SUCCESS}; + return {0, Errno::E_SUCCESS}; } for (size_t i = 0; i < pollfds.size(); ++i) @@ -919,7 +920,7 @@ std::pair Poll(std::span pollfds, s32 timeout) { ASSERT(res == SOCKET_ERROR); return {-1, GetAndLogLastError(CallType::Other)}; } - return {res, Errno::SUCCESS}; + return {res, Errno::E_SUCCESS}; } Socket::~Socket() { @@ -1035,7 +1036,7 @@ Errno Socket::GetSockOpt(Network::SocketLevel level, Network::OptName optname, s const int result = getsockopt(fd, native_level, native_optname, reinterpret_cast(value.data()), &len); if (result != SOCKET_ERROR) { ASSERT(len == socklen_t(value.size())); - return Errno::SUCCESS; + return Errno::E_SUCCESS; } return GetAndLogLastError(CallType::Other); } @@ -1043,7 +1044,7 @@ Errno Socket::GetSockOpt(Network::SocketLevel level, Network::OptName optname, s Errno Socket::SetNonBlock(bool enable) { if (EnableNonBlock(fd, enable)) { is_non_blocking = enable; - return Errno::SUCCESS; + return Errno::E_SUCCESS; } return GetAndLogLastError(CallType::Other); } @@ -1059,10 +1060,10 @@ Errno Socket::SetSockOpt(Network::SocketLevel level, Network::OptName optname, s std::memcpy(&linger, optval.data(), sizeof(linger)); auto const linger_optval = MakeLinger(bool(linger.onoff), linger.linger); if (setsockopt(fd, native_level, native_optname, reinterpret_cast(&linger_optval), sizeof(linger_optval)) != SOCKET_ERROR) - return Errno::SUCCESS; + return Errno::E_SUCCESS; return GetAndLogLastError(CallType::Other); } - return Errno::INVAL; + return Errno::E_INVAL; } else if (optname == Network::OptName::RCVTIMEO || optname == Network::OptName::SNDTIMEO) { if (optval.size() >= sizeof(Network::Timeval)) { Network::Timeval guest_tv{}; @@ -1071,20 +1072,20 @@ Errno Socket::SetSockOpt(Network::SocketLevel level, Network::OptName optname, s tv.tv_sec = guest_tv.tv_sec; tv.tv_usec = guest_tv.tv_usec; if (setsockopt(fd, native_level, native_optname, reinterpret_cast(&tv), sizeof(tv)) != SOCKET_ERROR) - return Errno::SUCCESS; + return Errno::E_SUCCESS; return GetAndLogLastError(CallType::Other); } - return Errno::INVAL; + return Errno::E_INVAL; } if (setsockopt(fd, native_level, native_optname, reinterpret_cast(optval.data()), socklen_t(optval.size())) != SOCKET_ERROR) - return Errno::SUCCESS; + return Errno::E_SUCCESS; return GetAndLogLastError(CallType::Other); } Errno Socket::Initialize(Domain domain, Type type, Protocol protocol) { fd = socket(TranslateDomainToNative(domain), TranslateTypeToNative(type), TranslateProtocolToNative(protocol)); if (fd != INVALID_SOCKET) - return Errno::SUCCESS; + return Errno::E_SUCCESS; return GetAndLogLastError(CallType::Other); } @@ -1102,7 +1103,7 @@ std::pair Socket::Accept() { pollres = WSAPoll(host_pollfds.data(), ULONG(host_pollfds.size()), -1); // Interrupt signaled before a client could be accepted, break if (host_pollfds[1].revents != 0) - return {AcceptResult{}, Errno::AGAIN}; + return {AcceptResult{}, Errno::E_AGAIN}; } } @@ -1116,7 +1117,7 @@ std::pair Socket::Accept() { .sockaddr_in = TranslateToSockAddrIn(addr), }; - return {std::move(result), Errno::SUCCESS}; + return {std::move(result), Errno::E_SUCCESS}; } Errno Socket::Connect(Network::SockAddrIn addr_in) { @@ -1124,7 +1125,7 @@ Errno Socket::Connect(Network::SockAddrIn addr_in) { if (EnableNonBlock(fd, false)) { if (connect(fd, reinterpret_cast(&host_addr_in), sizeof(host_addr_in)) != SOCKET_ERROR) { if (EnableNonBlock(fd, true)) { - return Errno::SUCCESS; + return Errno::E_SUCCESS; } } } @@ -1136,7 +1137,7 @@ std::pair Socket::GetPeerName() { socklen_t addrlen = sizeof(addr); if (getpeername(fd, reinterpret_cast(&addr), &addrlen) == SOCKET_ERROR) return {Network::SockAddrIn{}, GetAndLogLastError(CallType::Other)}; - return {TranslateToSockAddrIn(addr), Errno::SUCCESS}; + return {TranslateToSockAddrIn(addr), Errno::E_SUCCESS}; } std::pair Socket::GetSockName() { @@ -1146,19 +1147,19 @@ std::pair Socket::GetSockName() { return {Network::SockAddrIn{}, GetAndLogLastError(CallType::Other)}; } - return {TranslateToSockAddrIn(addr), Errno::SUCCESS}; + return {TranslateToSockAddrIn(addr), Errno::E_SUCCESS}; } Errno Socket::Bind(Network::SockAddrIn addr) { auto const addr_in = TranslateFromSockAddrIn(addr); if (bind(fd, reinterpret_cast(&addr_in), sizeof(addr_in)) != SOCKET_ERROR) - return Errno::SUCCESS; + return Errno::E_SUCCESS; return GetAndLogLastError(CallType::Other); } Errno Socket::Listen(s32 backlog) { if (listen(fd, backlog) != SOCKET_ERROR) - return Errno::SUCCESS; + return Errno::E_SUCCESS; return GetAndLogLastError(CallType::Other); } @@ -1176,10 +1177,10 @@ Errno Socket::Shutdown(ShutdownHow how) { break; default: UNIMPLEMENTED_MSG("Unimplemented flag how={}", how); - return Errno::SUCCESS; + return Errno::E_SUCCESS; } if (shutdown(fd, host_how) != SOCKET_ERROR) { - return Errno::SUCCESS; + return Errno::E_SUCCESS; } return GetAndLogLastError(CallType::Other); @@ -1224,7 +1225,7 @@ std::pair Socket::Recv(int flags, std::span message) { auto const native_flags = TranslateMsgOptToNative(flags); auto const result = recv(fd, reinterpret_cast(message.data()), int(message.size()), native_flags); if (result != SOCKET_ERROR) - return {s32(result), Errno::SUCCESS}; + return {s32(result), Errno::E_SUCCESS}; return {-1, GetAndLogLastError(CallType::Other)}; } @@ -1243,7 +1244,7 @@ std::pair Socket::RecvFrom(int flags, std::span message, Network if (addr) { *addr = TranslateToSockAddrIn(addr_in); } - return {s32(result), Errno::SUCCESS}; + return {s32(result), Errno::E_SUCCESS}; } return {-1, GetAndLogLastError(CallType::Other)}; } @@ -1259,7 +1260,7 @@ std::pair Socket::Send(std::span message, int flags) { #endif const auto result = send(fd, reinterpret_cast(message.data()), int(message.size()), native_flags); if (result != SOCKET_ERROR) - return {s32(result), Errno::SUCCESS}; + return {s32(result), Errno::E_SUCCESS}; return {-1, GetAndLogLastError(CallType::Send)}; } @@ -1283,7 +1284,7 @@ std::pair Socket::SendTo(u32 flags, std::span message, con const auto result = sendto(fd, reinterpret_cast(message.data()), int(message.size()), native_flags, reinterpret_cast(to), to_len); if (result != SOCKET_ERROR) - return {s32(result), Errno::SUCCESS}; + return {s32(result), Errno::E_SUCCESS}; return {-1, GetAndLogLastError(CallType::Send)}; } @@ -1294,7 +1295,7 @@ Errno Socket::Close() { } fd = INVALID_SOCKET; - return Errno::SUCCESS; + return Errno::E_SUCCESS; } std::pair Socket::GetPendingError() { diff --git a/src/core/internal_network/socket_icmp.cpp b/src/core/internal_network/socket_icmp.cpp index f94a36ea93..fa646028ce 100644 --- a/src/core/internal_network/socket_icmp.cpp +++ b/src/core/internal_network/socket_icmp.cpp @@ -44,54 +44,54 @@ Errno IcmpSocket::SetSockOpt(Network::SocketLevel level, Network::OptName optnam LOG_WARNING(Network, "(stubbed) level={},optname={},optval={}", level, optname, optval.size()); if (optname == Network::OptName::RCVTIMEO) { if (optval.size() < sizeof(Network::Timeval)) - return Errno::INVAL; + return Errno::E_INVAL; std::memcpy(&rcv_timeo, optval.data(), sizeof(rcv_timeo)); } - return Errno::SUCCESS; + return Errno::E_SUCCESS; } Errno IcmpSocket::Initialize(Domain domain, Type type, Protocol socket_protocol) { - return Errno::SUCCESS; + return Errno::E_SUCCESS; } std::pair IcmpSocket::Accept() { LOG_WARNING(Network, "(stubbed) called"); - return {AcceptResult{}, Errno::SUCCESS}; + return {AcceptResult{}, Errno::E_SUCCESS}; } Errno IcmpSocket::Connect(Network::SockAddrIn addr_in) { LOG_WARNING(Network, "(stubbed) called"); - return Errno::SUCCESS; + return Errno::E_SUCCESS; } std::pair IcmpSocket::GetPeerName() { LOG_WARNING(Network, "(stubbed) called"); - return {Network::SockAddrIn{}, Errno::SUCCESS}; + return {Network::SockAddrIn{}, Errno::E_SUCCESS}; } std::pair IcmpSocket::GetSockName() { LOG_WARNING(Network, "(stubbed) called"); - return {Network::SockAddrIn{}, Errno::SUCCESS}; + return {Network::SockAddrIn{}, Errno::E_SUCCESS}; } Errno IcmpSocket::Bind(Network::SockAddrIn addr) { LOG_WARNING(Network, "(stubbed) called"); - return Errno::SUCCESS; + return Errno::E_SUCCESS; } Errno IcmpSocket::Listen(s32 backlog) { LOG_WARNING(Network, "(stubbed) called"); - return Errno::SUCCESS; + return Errno::E_SUCCESS; } Errno IcmpSocket::Shutdown(ShutdownHow how) { LOG_WARNING(Network, "(stubbed) called"); - return Errno::SUCCESS; + return Errno::E_SUCCESS; } std::pair IcmpSocket::Recv(int flags, std::span message) { LOG_DEBUG(Network, "(stubbed) called"); - return {s32(0), Errno::NOTCONN}; + return {s32(0), Errno::E_NOTCONN}; } std::pair IcmpSocket::RecvFrom(int flags, std::span message, Network::SockAddrIn* addr) { @@ -101,7 +101,7 @@ std::pair IcmpSocket::RecvFrom(int flags, std::span message, Net #if !defined(__OPENORBIS__) && (defined(__FreeBSD__) || defined(__linux__)) if (addr) { if (seq_ident.empty()) - return {0, Errno::SUCCESS}; + return {0, Errno::E_SUCCESS}; // PLEASE DON'T KILL ME, I SWEAR THIS IS LEGITIMATELY THE BEST WAY TO DO IT // IF YOU OPEN socket() GOOGLE WILL STRAIGHT UP IP BAN YOU AFTER 2 HOURS auto const rcv_timeout = std::max(rcv_timeo.tv_sec, 1); @@ -127,12 +127,12 @@ std::pair IcmpSocket::RecvFrom(int flags, std::span message, Net data[3] = u8(csum); //lo auto const n = (std::max)(data.size(), message.size()); std::copy(data.begin(), data.begin() + n, message.begin()); - return {n, Errno::SUCCESS}; + return {n, Errno::E_SUCCESS}; } - return {-1, Errno::TIMEDOUT}; + return {-1, Errno::E_TIMEDOUT}; } #endif - return {-1, Errno::INVAL}; + return {-1, Errno::E_INVAL}; } std::pair IcmpSocket::Send(std::span message, int flags) { @@ -143,7 +143,7 @@ std::pair IcmpSocket::Send(std::span message, int flags) { | (u32(message[6]) << 8) | (u32(message[7]) << 0) ); - return {s32(0), Errno::NOTCONN}; + return {s32(0), Errno::E_NOTCONN}; } std::pair IcmpSocket::SendTo(u32 flags, std::span message, const Network::SockAddrIn* addr) { @@ -155,19 +155,19 @@ std::pair IcmpSocket::SendTo(u32 flags, std::span message, // 4..6 -> ident // 6..8 -> seq if (!message.empty()) - return {s32(message.size()), Errno::SUCCESS}; - return {-1, Errno::INVAL}; + return {s32(message.size()), Errno::E_SUCCESS}; + return {-1, Errno::E_INVAL}; } Errno IcmpSocket::Close() { LOG_DEBUG(Network, "called"); fd = INVALID_SOCKET; - return Errno::SUCCESS; + return Errno::E_SUCCESS; } std::pair IcmpSocket::GetPendingError() { LOG_DEBUG(Network, "called"); - return {Errno::SUCCESS, Errno::SUCCESS}; + return {Errno::E_SUCCESS, Errno::E_SUCCESS}; } bool IcmpSocket::IsOpened() const { @@ -178,7 +178,7 @@ void IcmpSocket::HandleProxyPacket(const ProxyPacket& packet) { LOG_WARNING(Network, "(stubbed) called"); } Errno IcmpSocket::SetNonBlock(bool enable) { - return Errno::SUCCESS; + return Errno::E_SUCCESS; } } // namespace Network diff --git a/src/core/internal_network/socket_proxy.cpp b/src/core/internal_network/socket_proxy.cpp index cd2818ee9b..15ec16d0ae 100644 --- a/src/core/internal_network/socket_proxy.cpp +++ b/src/core/internal_network/socket_proxy.cpp @@ -49,7 +49,7 @@ void ProxySocket::HandleProxyPacket(const ProxyPacket& packet) { Errno ProxySocket::SetNonBlock(bool enable) { blocking = !enable; - return Errno::SUCCESS; + return Errno::E_SUCCESS; } Errno ProxySocket::SetSockOpt(Network::SocketLevel level, Network::OptName optname, std::span optval) { @@ -65,59 +65,59 @@ Errno ProxySocket::SetSockOpt(Network::SocketLevel level, Network::OptName optna if (optname == Network::OptName::RCVTIMEO) receive_timeout = value; } - return Errno::SUCCESS; + return Errno::E_SUCCESS; } Errno ProxySocket::Initialize(Domain domain, Type type, Protocol socket_protocol) { protocol = socket_protocol; - return Errno::SUCCESS; + return Errno::E_SUCCESS; } std::pair ProxySocket::Accept() { LOG_WARNING(Network, "(stubbed) called"); - return {AcceptResult{}, Errno::SUCCESS}; + return {AcceptResult{}, Errno::E_SUCCESS}; } Errno ProxySocket::Connect(Network::SockAddrIn addr_in) { LOG_WARNING(Network, "(stubbed) called"); - return Errno::SUCCESS; + return Errno::E_SUCCESS; } std::pair ProxySocket::GetPeerName() { LOG_WARNING(Network, "(stubbed) called"); - return {Network::SockAddrIn{}, Errno::SUCCESS}; + return {Network::SockAddrIn{}, Errno::E_SUCCESS}; } std::pair ProxySocket::GetSockName() { LOG_WARNING(Network, "(stubbed) called"); - return {Network::SockAddrIn{}, Errno::SUCCESS}; + return {Network::SockAddrIn{}, Errno::E_SUCCESS}; } Errno ProxySocket::Bind(Network::SockAddrIn addr) { if (is_bound) { LOG_WARNING(Network, "Rebinding Socket is unimplemented!"); - return Errno::SUCCESS; + return Errno::E_SUCCESS; } local_endpoint = addr; is_bound = true; - return Errno::SUCCESS; + return Errno::E_SUCCESS; } Errno ProxySocket::Listen(s32 backlog) { LOG_WARNING(Network, "(stubbed) called"); - return Errno::SUCCESS; + return Errno::E_SUCCESS; } Errno ProxySocket::Shutdown(ShutdownHow how) { LOG_WARNING(Network, "(stubbed) called"); - return Errno::SUCCESS; + return Errno::E_SUCCESS; } std::pair ProxySocket::Recv(int flags, std::span message) { LOG_WARNING(Network, "(stubbed) called"); ASSERT(flags == 0); ASSERT(message.size() < std::size_t((std::numeric_limits::max)())); - return {s32(0), Errno::SUCCESS}; + return {s32(0), Errno::E_SUCCESS}; } std::pair ProxySocket::RecvFrom(int flags, std::span message, Network::SockAddrIn* addr) { @@ -139,7 +139,7 @@ std::pair ProxySocket::RecvFrom(int flags, std::span message, Ne } if (!blocking) { - return {-1, Errno::AGAIN}; + return {-1, Errno::E_AGAIN}; } std::this_thread::yield(); @@ -147,7 +147,7 @@ std::pair ProxySocket::RecvFrom(int flags, std::span message, Ne const auto time_diff = std::chrono::steady_clock::now() - timestamp; const auto time_diff_ms = std::chrono::duration_cast(time_diff).count(); if (time_diff_ms > timeout) { - return {-1, Errno::TIMEDOUT}; + return {-1, Errno::E_TIMEDOUT}; } } } @@ -173,7 +173,7 @@ std::pair ProxySocket::ReceivePacket(int flags, std::span messag if (!peek) { received_packets.pop(); } - return {-1, Errno::MSGSIZE}; + return {-1, Errno::E_MSGSIZE}; } else if (protocol == Protocol::TCP) { std::vector numArray(packet.data.size() - max_length); std::copy(packet.data.begin() + max_length, packet.data.end(), std::back_inserter(numArray)); @@ -187,14 +187,14 @@ std::pair ProxySocket::ReceivePacket(int flags, std::span messag } } - return {u32(read_bytes), Errno::SUCCESS}; + return {u32(read_bytes), Errno::E_SUCCESS}; } std::pair ProxySocket::Send(std::span message, int flags) { LOG_WARNING(Network, "(stubbed) called"); ASSERT(message.size() < size_t((std::numeric_limits::max)())); ASSERT(flags == 0); - return {s32(0), Errno::SUCCESS}; + return {s32(0), Errno::E_SUCCESS}; } void ProxySocket::SendPacket(ProxyPacket& packet) { @@ -212,12 +212,12 @@ std::pair ProxySocket::SendTo(u32 flags, std::span message if (!is_bound) { LOG_ERROR(Network, "ProxySocket is not bound!"); - return {s32(message.size()), Errno::SUCCESS}; + return {s32(message.size()), Errno::E_SUCCESS}; } if (auto room_member = Network::GetRoomMember().lock()) { if (!room_member->IsConnected()) { - return {s32(message.size()), Errno::SUCCESS}; + return {s32(message.size()), Errno::E_SUCCESS}; } } @@ -242,7 +242,7 @@ std::pair ProxySocket::SendTo(u32 flags, std::span message SendPacket(packet); - return {s32(message.size()), Errno::SUCCESS}; + return {s32(message.size()), Errno::E_SUCCESS}; } Errno ProxySocket::Close() { @@ -250,12 +250,12 @@ Errno ProxySocket::Close() { fd = INVALID_SOCKET; closed = true; - return Errno::SUCCESS; + return Errno::E_SUCCESS; } std::pair ProxySocket::GetPendingError() { LOG_DEBUG(Network, "called"); - return {Errno::SUCCESS, Errno::SUCCESS}; + return {Errno::E_SUCCESS, Errno::E_SUCCESS}; } bool ProxySocket::IsOpened() const { diff --git a/src/core/internal_network/socket_types.h b/src/core/internal_network/socket_types.h index 67a439f061..6006502cf6 100644 --- a/src/core/internal_network/socket_types.h +++ b/src/core/internal_network/socket_types.h @@ -19,39 +19,139 @@ namespace Network { enum class Errno : u32 { - SUCCESS = 0, - NOENT = 2, - INTR = 4, - IO = 5, - NOEXEC = 8, - BADF = 9, - AGAIN = 11, - INVAL = 22, - MFILE = 24, - PIPE = 32, - NOTSOCK = 88, - MSGSIZE = 90, - PROTOTYPE = 91, - NOPROTOOPT = 92, - PROTONOSUPPORT = 93, - SOCKTNOSUPPORT = 94, - NOTSUP = 95, - ADDRINUSE = 98, - ADDRNOTAVAIL = 99, - NETDOWN = 100, - NETUNREACH = 101, - CONNABORTED = 103, - CONNRESET = 104, - ISCONN = 106, - NOTCONN = 107, - TIMEDOUT = 110, - CONNREFUSED = 111, - HOSTUNREACH = 113, - ALREADY = 114, - INPROGRESS = 115, - STALE = 116, - /* made up error? */ - OTHER = 196, + E_SUCCESS = 0, + E_PERM = 1, + E_NOENT = 2, + E_SRCH = 3, + E_INTR = 4, + E_IO = 5, + E_NXIO = 6, + E_2BIG = 7, + E_NOEXEC = 8, + E_BADF = 9, + E_CHILD = 10, + E_AGAIN = 11, + E_NOMEM = 12, + E_ACCES = 13, + E_FAULT = 14, + E_NOTBLK = 15, + E_BUSY = 16, + E_EXIST = 17, + E_XDEV = 18, + E_NODEV = 19, + E_NOTDIR = 20, + E_ISDIR = 21, + E_INVAL = 22, + E_NFILE = 23, + E_MFILE = 24, + E_NOTTY = 25, + E_TXTBSY = 26, + E_FBIG = 27, + E_NOSPC = 28, + E_SPIPE = 29, + E_ROFS = 30, + E_MLINK = 31, + E_PIPE = 32, + E_DOM = 33, + E_RANGE = 34, + E_DEADLK = 35, + E_NAMETOOLONG = 36, + E_NOLCK = 37, + E_NOSYS = 38, + E_NOTEMPTY = 39, + E_LOOP = 40, + E_NOMSG = 42, + E_IDRM = 43, + E_CHRNG = 44, + E_L2NSYNC = 45, + E_L3HLT = 46, + E_L3RST = 47, + E_LNRNG = 48, + E_UNATCH = 49, + E_NOCSI = 50, + E_L2HLT = 51, + E_BADE = 52, + E_BADR = 53, + E_XFULL = 54, + E_NOANO = 55, + E_BADRQC = 56, + E_BADSSL = 57, + E_BFONT = 59, + E_NOSTR = 60, + E_NODATA = 61, + E_TIME = 62, + E_NOSR = 63, + E_NONET = 64, + E_NOPKG = 65, + E_REMOTE = 66, + E_NOLINK = 67, + E_ADV = 68, + E_SRMNT = 69, + E_COMM = 70, + E_PROTO = 71, + E_MULTIHOP = 72, + E_DOTDOT = 73, + E_BADMSG = 74, + E_OVERFLOW = 75, + E_NOTUNUQ = 76, + E_BADFD = 77, + E_REMCHG = 78, + E_LIBACC = 79, + E_LIBBAD = 80, + E_LIBSCN = 81, + E_LIBMAX = 82, + E_LIBEXEC = 83, + E_ILSEQ = 84, + E_RESTART = 85, + E_STRPIPE = 86, + E_USERS = 87, + E_NOTSOCK = 88, + E_DESTADDRREQ = 89, + E_MSGSIZE = 90, + E_PROTOTYPE = 91, + E_NOPROTOOPT = 92, + E_PROTONOSUPPORT = 93, + E_SOCKTNOSUPPORT = 94, + E_OPNOTSUPP = 95, + E_PFNOSUPPORT = 96, + E_AFNOSUPPORT = 97, + E_ADDRINUSE = 98, + E_ADDRNOTAVAIL = 99, + E_NETDOWN = 100, + E_NETUNREACH = 101, + E_NETRESET = 102, + E_CONNABORTED = 103, + E_CONNRESET = 104, + E_NOBUFS = 105, + E_ISCONN = 106, + E_NOTCONN = 107, + E_SHUTDOWN = 108, + E_TOOMANYREFS = 109, + E_TIMEDOUT = 110, + E_CONNREFUSED = 111, + E_HOSTDOWN = 112, + E_HOSTUNREACH = 113, + E_ALREADY = 114, + E_INPROGRESS = 115, + E_STALE = 116, + E_UCLEAN = 117, + E_NOTNAM = 118, + E_NAVAIL = 119, + E_ISNAM = 120, + E_REMOTEIO = 121, + E_DQUOT = 122, + E_NOMEDIUM = 123, + E_MEDIUMTYPE = 124, + E_CANCELED = 125, + E_NOKEY = 126, + E_KEYEXPIRED = 127, + E_KEYREVOKED = 128, + E_KEYREJECTED = 129, + E_OWNERDEAD = 130, + E_NOTRECOVERABLE = 131, + E_RFKILL = 132, + E_HWPOISON = 133, + E_PROCLIM = 156, }; enum class GetAddrInfoError : s32 { diff --git a/src/tests/core/internal_network/network.cpp b/src/tests/core/internal_network/network.cpp index c681dbbda8..c7cb7bf02f 100644 --- a/src/tests/core/internal_network/network.cpp +++ b/src/tests/core/internal_network/network.cpp @@ -15,7 +15,7 @@ TEST_CASE("Network::Errors", "[core]") { Network::Socket socks[2]; for (Network::Socket& sock : socks) { REQUIRE(sock.Initialize(Network::Domain::INET, Network::Type::STREAM, - Network::Protocol::TCP) == Network::Errno::SUCCESS); + Network::Protocol::TCP) == Network::Errno::E_SUCCESS); } Network::SockAddrIn addr{ @@ -25,8 +25,8 @@ TEST_CASE("Network::Errors", "[core]") { {127, 0, 0, 1}, {}, }; - REQUIRE(socks[0].Connect(addr) == Network::Errno::CONNREFUSED); + REQUIRE(socks[0].Connect(addr) == Network::Errno::E_CONNREFUSED); std::vector message{1, 2, 3, 4}; - REQUIRE(socks[1].Recv(0, message).second == Network::Errno::NOTCONN); + REQUIRE(socks[1].Recv(0, message).second == Network::Errno::E_NOTCONN); }