ok windows

Signed-off-by: lizzie <lizzie@eden-emu.dev>

externals/tz/tz/tz.h

@@ -11,7 +11,6 @@
 #include <limits>
 #include <span>
 #include <array>
-#include <algorithm>
 #include <time.h>
 
 namespace Tz {

src/common/CMakeLists.txt

@@ -108,7 +108,6 @@ add_library(
     settings_input.h
     settings_setting.h
     slot_vector.h
-    socket_types.h
     spin_lock.h
     stb.cpp
     stb.h

src/common/announce_multiplayer_room.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2017 Citra Emulator Project
@@ -11,7 +11,7 @@
 #include <string>
 #include <vector>
 #include "common/common_types.h"
-#include "common/socket_types.h"
+#include "core/internal_network/socket_types.h"
 #include "web_service/web_result.h"
 
 namespace AnnounceMultiplayerRoom {

src/common/demangle.cpp

@@ -5,7 +5,6 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include <string>
-#include <cstdlib>
 #include <string_view>
 #ifdef _WIN32
 #include <llvm/Demangle/Demangle.h>

src/common/socket_types.h

@@ -1,178 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <optional>
-#include <string>
-
-#include "common/common_types.h"
-
-namespace Network {
-
-/// Address families
-enum class Domain : u8 {
-    Unspecified, ///< Represents 0, used in getaddrinfo hints
-    INET,        ///< Address family for IPv4
-};
-
-/// Socket types
-enum class Type {
-    Unspecified, ///< Represents 0, used in getaddrinfo hints
-    STREAM,
-    DGRAM,
-    RAW,
-    SEQPACKET,
-};
-
-/// Protocol values for sockets
-enum class Protocol : u8 {
-    Unspecified, ///< Represents 0, usable in various places
-    IP,
-    ICMP,
-    TCP,
-    UDP,
-    IPV6,
-    RAW,
-    IGMP,
-    GGP,
-    IPV4,
-    ST,
-    EGP,
-    PIGP,
-    RCCMON,
-    NVPII,
-    PUP,
-    ARGUS,
-    EMCON,
-    XNET,
-    CHAOS,
-    MUX,
-    MEAS,
-    HMP,
-    PRM,
-    IDP,
-    TRUNK1,
-    TRUNK2,
-    LEAF1,
-    LEAF2,
-    RDP,
-    IRTP,
-    TP,
-    BLT,
-    NSP,
-    INP,
-    DCCP,
-    //TODO: 3PC,
-    IDPR,
-    XTP,
-    DDP,
-    CMTP,
-    TPXX,
-    IL,
-    SDRP,
-    ROUTING,
-    FRAGMENT,
-    IDRP,
-    RSVP,
-    GRE,
-    MHRP,
-    BHA,
-    ESP,
-    AH,
-    INLSP,
-    SWIPE,
-    NHRP,
-    MOBILE,
-    TLSP,
-    SKIP,
-    ICMPV6,
-    NONE,
-    DSTOPTS,
-    AHIP,
-    CFTP,
-    HELLO,
-    SATEXPAK,
-    KRYPTOLAN,
-    RVD,
-    IPPC,
-    ADFS,
-    SATMON,
-    VISA,
-    IPCV,
-    CPNX,
-    CPHB,
-    WSN,
-    PVP,
-    BRSATMON,
-    ND,
-    WBMON,
-    WBEXPAK,
-    EON,
-    VMTP,
-    SVMTP,
-    VINES,
-    TTP,
-    IGP,
-    DGP,
-    TCF,
-    IGRP,
-    OSPFIGP,
-    SRPC,
-    LARP,
-    MTP,
-    AX25,
-    IPEIP,
-    MICP,
-    SCCSP,
-    ETHERIP,
-    ENCAP,
-    APES,
-    GMTP,
-    IPCOMP,
-    SCTP,
-    MH,
-    UDPLITE,
-    HIP,
-    SHIM6,
-    PIM,
-    CARP,
-    PGM,
-    MPLS,
-    PFSYNC
-};
-
-/// Shutdown mode
-enum class ShutdownHow {
-    RD,
-    WR,
-    RDWR,
-};
-
-/// Array of IPv4 address
-using IPv4Address = std::array<u8, 4>;
-
-/// Cross-platform sockaddr structure
-struct SockAddrIn {
-    Domain family;
-    IPv4Address ip;
-    u16 portno;
-};
-
-constexpr u32 FLAG_MSG_PEEK = 0x2;
-constexpr u32 FLAG_MSG_DONTWAIT = 0x80;
-constexpr u32 FLAG_O_NONBLOCK = 0x800;
-
-/// Cross-platform addrinfo structure
-struct AddrInfo {
-    Domain family;
-    Type socket_type;
-    Protocol protocol;
-    SockAddrIn addr;
-    std::optional<std::string> canon_name;
-};
-
-} // namespace Network

src/core/CMakeLists.txt

@@ -1129,6 +1129,7 @@ add_library(core STATIC
     internal_network/network_interface.h
     internal_network/socket_proxy.cpp
     internal_network/socket_proxy.h
+    internal_network/socket_types.h
     internal_network/sockets.h
     internal_network/wifi_scanner.h
     launch_timestamp_cache.cpp
@@ -1167,6 +1168,12 @@ add_library(core STATIC
     tools/renderdoc.cpp
     tools/renderdoc.h)
 
+if (UNIX AND NOT APPLE)
+    target_sources(core PRIVATE
+        internal_network/socket_icmp.cpp
+        internal_network/socket_icmp.h)
+endif()
+
 if (ENABLE_WIFI_SCAN)
     target_sources(core PRIVATE internal_network/wifi_scanner.cpp)
     if (LINUX)

src/core/hle/service/ldn/lan_discovery.h

@@ -18,7 +18,7 @@
 #include "common/container/unordered_map.h"
 
 #include "common/logging.h"
-#include "common/socket_types.h"
+#include "core/internal_network/socket_types.h"
 #include "core/hle/result.h"
 #include "core/hle/service/ldn/ldn_results.h"
 #include "core/hle/service/ldn/ldn_types.h"

src/core/hle/service/server_manager.cpp

@@ -129,6 +129,13 @@ ServerManager::~ServerManager() {
     }
 }
 
+void ServerManager::StartAdditionalHostThreads(const char* name, size_t num_threads) {
+    for (size_t i = 0; i < num_threads; i++) {
+        auto thread_name = fmt::format("{}:{}", name, i + 1);
+        m_threads.emplace_back(m_system.Kernel().RunOnHostCoreThread(std::move(thread_name), [&] { this->LoopProcessImpl(); }));
+    }
+}
+
 void ServerManager::RunServer(std::unique_ptr<ServerManager>&& server_manager) {
     server_manager->m_system.RunServer(std::move(server_manager));
 }
@@ -245,14 +252,6 @@ Result ServerManager::ManageDeferral(Kernel::KEvent** out_event) {
     R_SUCCEED();
 }
 
-void ServerManager::StartAdditionalHostThreads(const char* name, size_t num_threads) {
-    for (size_t i = 0; i < num_threads; i++) {
-        auto thread_name = fmt::format("{}:{}", name, i + 1);
-        m_threads.emplace_back(m_system.Kernel().RunOnHostCoreThread(
-            std::move(thread_name), [&] { this->LoopProcessImpl(); }));
-    }
-}
-
 Result ServerManager::LoopProcess() {
     SCOPE_EXIT {
         m_stopped.Set();

src/core/hle/service/server_manager.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -48,8 +51,8 @@ public:
     Result ManageDeferral(Kernel::KEvent** out_event);
 
     Result LoopProcess();
-    void StartAdditionalHostThreads(const char* name, size_t num_threads);
 
+    void StartAdditionalHostThreads(const char* name, size_t num_threads);
     static void RunServer(std::unique_ptr<ServerManager>&& server);
 
 private:

src/core/hle/service/sockets/bsd.cpp

@@ -12,7 +12,7 @@
 #include <fmt/ranges.h>
 
 #include "common/logging.h"
-#include "common/socket_types.h"
+#include "core/internal_network/socket_types.h"
 #include "core/core.h"
 #include "core/hle/kernel/k_thread.h"
 #include "core/hle/service/ipc_helpers.h"
@@ -20,6 +20,9 @@
 #include "core/hle/service/sockets/sockets_translate.h"
 #include "core/internal_network/network.h"
 #include "core/internal_network/socket_proxy.h"
+#if defined(__unix__) && !defined(__APPLE__)
+#include "core/internal_network/socket_icmp.h"
+#endif
 #include "core/internal_network/sockets.h"
 #include "network/network.h"
 #include <common/settings.h>
@@ -28,15 +31,18 @@ namespace Service::Sockets {
 
 namespace {
 
-bool IsConnectionBased(Type type) {
+[[nodiscard]] bool IsConnectionBased(Network::Type type) noexcept {
     switch (type) {
-    case Type::STREAM:
+    case Network::Type::STREAM:
+    case Network::Type::SEQPACKET:
         return true;
-    case Type::DGRAM:
+    case Network::Type::RAW:
+    case Network::Type::DGRAM:
+    case Network::Type::RDM:
+    case Network::Type::Unspecified:
         return false;
     default:
-        UNIMPLEMENTED_MSG("Unimplemented type={}", type);
-        return false;
+        UNREACHABLE();
     }
 }
 
@@ -92,7 +98,7 @@ void BSD_USA::ConnectWork::Execute(BSD_USA* bsd) {
 void BSD_USA::ConnectWork::Response(HLERequestContext& ctx) {
     IPC::ResponseBuilder rb{ctx, 4};
     rb.Push(ResultSuccess);
-    rb.Push<s32>(bsd_errno == Errno::SUCCESS ? 0 : -1);
+    rb.Push<s32>(bsd_errno == Network::Errno::E_SUCCESS ? 0 : -1);
     rb.PushEnum(bsd_errno);
 }
 
@@ -170,10 +176,9 @@ void BSD_USA::Socket(HLERequestContext& ctx) {
     const u32 domain = rp.Pop<u32>();
     const u32 type = rp.Pop<u32>();
     const u32 protocol = rp.Pop<u32>();
-
     LOG_DEBUG(Service, "called. domain={} type={} protocol={}", domain, type, protocol);
 
-    const auto [fd, bsd_errno] = SocketImpl(Domain(domain), Type(type), Protocol(protocol));
+    const auto [fd, bsd_errno] = SocketImpl(Network::Domain(domain), Network::Type(type), Network::Protocol(protocol));
 
     IPC::ResponseBuilder rb{ctx, 4};
     rb.Push(ResultSuccess);
@@ -189,8 +194,8 @@ void BSD_USA::SocketExempt(HLERequestContext& ctx) {
 
     LOG_DEBUG(Service, "called. domain={} type={} protocol={}", domain, type, protocol);
 
-    auto [fd, bsd_errno] = SocketImpl(Domain(domain), Type(type), Protocol(protocol));
-    if (bsd_errno == Errno::SUCCESS) {
+    auto [fd, bsd_errno] = SocketImpl(Network::Domain(domain), Network::Type(type), Network::Protocol(protocol));
+    if (bsd_errno == Network::Errno::E_SUCCESS) {
         bsd_errno = ShutdownImpl(fd, 0);
     }
 
@@ -264,13 +269,13 @@ void BSD_USA::GetPeerName(HLERequestContext& ctx) {
     LOG_DEBUG(Service, "called. fd={}", fd);
 
     std::vector<u8> write_buffer(ctx.GetWriteBufferSize());
-    const Errno bsd_errno = GetPeerNameImpl(fd, write_buffer);
+    const Network::Errno bsd_errno = GetPeerNameImpl(fd, write_buffer);
 
     ctx.WriteBuffer(write_buffer);
 
     IPC::ResponseBuilder rb{ctx, 5};
     rb.Push(ResultSuccess);
-    rb.Push<s32>(bsd_errno != Errno::SUCCESS ? -1 : 0);
+    rb.Push<s32>(bsd_errno != Network::Errno::E_SUCCESS ? -1 : 0);
     rb.PushEnum(bsd_errno);
     rb.Push<u32>(static_cast<u32>(write_buffer.size()));
 }
@@ -282,13 +287,13 @@ void BSD_USA::GetSockName(HLERequestContext& ctx) {
     LOG_DEBUG(Service, "called. fd={}", fd);
 
     std::vector<u8> write_buffer(ctx.GetWriteBufferSize());
-    const Errno bsd_errno = GetSockNameImpl(fd, write_buffer);
+    const Network::Errno bsd_errno = GetSockNameImpl(fd, write_buffer);
 
     ctx.WriteBuffer(write_buffer);
 
     IPC::ResponseBuilder rb{ctx, 5};
     rb.Push(ResultSuccess);
-    rb.Push<s32>(bsd_errno != Errno::SUCCESS ? -1 : 0);
+    rb.Push<s32>(bsd_errno != Network::Errno::E_SUCCESS ? -1 : 0);
     rb.PushEnum(bsd_errno);
     rb.Push<u32>(static_cast<u32>(write_buffer.size()));
 }
@@ -296,21 +301,19 @@ void BSD_USA::GetSockName(HLERequestContext& ctx) {
 void BSD_USA::GetSockOpt(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const s32 fd = rp.Pop<s32>();
-    const u32 level = rp.Pop<u32>();
-    const auto optname = static_cast<OptName>(rp.Pop<u32>());
+    const auto level = Network::SocketLevel(rp.Pop<u32>());
+    const auto optname = Network::OptName(rp.Pop<u32>());
 
     std::vector<u8> optval(ctx.GetWriteBufferSize());
 
-    LOG_DEBUG(Service, "called. fd={} level={} optname={:#x} len={:#x}", fd, level, optname,
-              optval.size());
-
-    const Errno err = GetSockOptImpl(fd, level, optname, optval);
+    LOG_DEBUG(Service, "called. fd={} level={} optname={:#x} len={:#x}", fd, level, optname, optval.size());
+    const Network::Errno err = GetSockOptImpl(fd, level, optname, optval);
 
     ctx.WriteBuffer(optval);
 
     IPC::ResponseBuilder rb{ctx, 5};
     rb.Push(ResultSuccess);
-    rb.Push<s32>(err == Errno::SUCCESS ? 0 : -1);
+    rb.Push<s32>(err == Network::Errno::E_SUCCESS ? 0 : -1);
     rb.PushEnum(err);
     rb.Push<u32>(static_cast<u32>(optval.size()));
 }
@@ -333,7 +336,7 @@ void BSD_USA::Fcntl(HLERequestContext& ctx) {
 
     LOG_DEBUG(Service, "called. fd={} cmd={} arg={}", fd, cmd, arg);
 
-    const auto [ret, bsd_errno] = FcntlImpl(fd, static_cast<FcntlCmd>(cmd), arg);
+    const auto [ret, bsd_errno] = FcntlImpl(fd, Network::FcntlCmd(cmd), arg);
 
     IPC::ResponseBuilder rb{ctx, 4};
     rb.Push(ResultSuccess);
@@ -345,13 +348,11 @@ void BSD_USA::SetSockOpt(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
 
     const s32 fd = rp.Pop<s32>();
-    const u32 level = rp.Pop<u32>();
-    const OptName optname = static_cast<OptName>(rp.Pop<u32>());
+    const Network::SocketLevel level = Network::SocketLevel(rp.Pop<u32>());
+    const Network::OptName optname = Network::OptName(rp.Pop<u32>());
     const auto optval = ctx.ReadBuffer();
 
-    LOG_DEBUG(Service, "called. fd={} level={} optname={:#x} optlen={}", fd, level,
-              static_cast<u32>(optname), optval.size());
-
+    LOG_DEBUG(Service, "called. fd={} level={} optname={:#x} optlen={}", fd, level, u32(optname), optval.size());
     BuildErrnoResponse(ctx, SetSockOptImpl(fd, level, optname, optval));
 }
 
@@ -473,7 +474,7 @@ void BSD_USA::DuplicateSocket(HLERequestContext& ctx) {
 
     struct OutputParameters {
         s32 ret;
-        Errno bsd_errno;
+        Network::Errno bsd_errno;
     };
     static_assert(sizeof(OutputParameters) == 0x8);
 
@@ -485,7 +486,7 @@ void BSD_USA::DuplicateSocket(HLERequestContext& ctx) {
     if (is_user) {
         rb.PushRaw(OutputParameters{
             .ret = 0,
-            .bsd_errno = Errno::INVAL,
+            .bsd_errno = Network::Errno::E_INVAL,
         });
         return;
     }
@@ -494,10 +495,10 @@ void BSD_USA::DuplicateSocket(HLERequestContext& ctx) {
     if (auto* res = std::get_if<s32>(&res_v)) {
         rb.PushRaw(OutputParameters{
             .ret = *res,
-            .bsd_errno = Errno::SUCCESS,
+            .bsd_errno = Network::Errno::E_SUCCESS,
         });
     } else {
-        auto* err = std::get_if<Errno>(&res_v);
+        auto* err = std::get_if<Network::Errno>(&res_v);
         rb.PushRaw(OutputParameters{
             .ret = 0,
             .bsd_errno = *err,
@@ -512,7 +513,7 @@ void BSD_USA::EventFd(HLERequestContext& ctx) {
 
     LOG_WARNING(Service, "(STUBBED) called. initval={}, flags={}", initval, flags);
 
-    BuildErrnoResponse(ctx, Errno::SUCCESS);
+    BuildErrnoResponse(ctx, Network::Errno::E_SUCCESS);
 }
 
 template <typename Work>
@@ -521,132 +522,143 @@ void BSD_USA::ExecuteWork(HLERequestContext& ctx, Work work) {
     work.Response(ctx);
 }
 
-std::pair<s32, Errno> BSD_USA::SocketImpl(Domain domain, Type type, Protocol protocol) {
+std::pair<s32, Network::Errno> BSD_USA::SocketImpl(Network::Domain domain, Network::Type type, Network::Protocol protocol) {
     // user bsd:u has restrictions on SOCK_SEQPACKET and SOCK_RAW
-    if (is_user && (type == Type::SEQPACKET || type == Type::RAW)) {
-        if (type == Type::RAW && domain == Domain::INET && protocol == Protocol::ICMP) {
+    LOG_DEBUG(Network, "domain={},type={},protocol={}", u32(domain), u32(type), u32(protocol));
+    if (is_user && (type == Network::Type::SEQPACKET || type == Network::Type::RAW)) {
+        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, Errno::INVAL};
+            return {-1, Network::Errno::E_INVAL};
         }
     }
 
-    [[maybe_unused]] const bool unk_flag = (static_cast<u32>(type) & 0x20000000) != 0;
+    [[maybe_unused]] const bool unk_flag = (u32(type) & 0x20000000) != 0;
     UNIMPLEMENTED_IF_MSG(unk_flag, "Unknown flag in type");
-    type = static_cast<Type>(static_cast<u32>(type) & ~0x20000000);
+    type = Network::Type(u32(type) & ~0x20000000);
 
     const s32 fd = FindFreeFileDescriptorHandle();
     if (fd < 0) {
         LOG_ERROR(Service, "No more file descriptors available");
-        return {-1, 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::E_NOTCONN};
     }
 
     file_descriptors[fd] = FileDescriptor{};
     FileDescriptor& descriptor = *file_descriptors[fd];
+
     // ENONMEM might be thrown here
+    LOG_INFO(Service, "New socket fd={},domain={},type={},prot={}", fd, domain, type, protocol);
 
-    LOG_INFO(Service, "New socket fd={}", fd);
-
+    // While room is important -- we need to remember ICMP takes priority over **everything else**
+    // TODO: rework this so proxy sockets can be done transparently? -- like what if i need
+    // to browse the internet while playing LDN or something stupid like that?
     auto room_member = Network::GetRoomMember().lock();
-    if (room_member && room_member->IsConnected()) {
+    if ((protocol != Network::Protocol::ICMP && protocol != Network::Protocol::ICMPV6)
+    && (room_member && room_member->IsConnected())) {
         descriptor.socket = std::make_shared<Network::ProxySocket>();
+        descriptor.socket->fd = fd;
     } else {
         descriptor.socket = std::make_shared<Network::Socket>();
     }
+    auto const bsd_errno = descriptor.socket->Initialize(domain, type, protocol);
 
-    descriptor.socket->Initialize(Translate(domain), Translate(type), Translate(protocol));
-    descriptor.is_connection_based = IsConnectionBased(type);
-
-    if (Settings::values.airplane_mode.GetValue() && descriptor.is_connection_based) {
-        LOG_ERROR(Service, "Airplane mode is enabled, cannot create socket");
-        return {-1, Errno::NOTCONN};
+#if defined(__unix__) && !defined(__APPLE__)
+    // ...only unix has this issue it seems, ICMP works otherwise fine on win
+    if ((protocol == Network::Protocol::ICMP || protocol == Network::Protocol::ICMPV6)
+    && bsd_errno != Network::Errno::E_SUCCESS) {
+        LOG_WARNING(Network, "Using ICMP emulated socket");
+        descriptor.socket = std::make_shared<Network::IcmpSocket>();
+        descriptor.socket->fd = fd;
     }
-
-    return {fd, Errno::SUCCESS};
+#endif
+    descriptor.is_connection_based = IsConnectionBased(type);
+#ifdef _WIN32
+    if (descriptor.is_connection_based && descriptor.socket->fd == INVALID_SOCKET) {
+#else
+    if (descriptor.is_connection_based && descriptor.socket->fd == Network::Socket::INVALID_SOCKET) {
+#endif
+        file_descriptors[fd].reset();
+        return {-1, bsd_errno};
+    }
+    return {fd, Network::Errno::E_SUCCESS};
 }
 
-std::pair<s32, Errno> BSD_USA::PollImpl(std::vector<u8>& write_buffer, std::span<const u8> read_buffer,
-                                    s32 nfds, s32 timeout) {
+std::pair<s32, Network::Errno> BSD_USA::PollImpl(std::vector<u8>& write_buffer, std::span<const u8> 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, Errno::SUCCESS};
+        return {-1, Network::Errno::E_SUCCESS};
     }
-    if (read_buffer.size() < nfds * sizeof(PollFD)) {
-        return {-1, Errno::INVAL};
+    if (read_buffer.size() < nfds * sizeof(Network::PollFD)) {
+        return {-1, Network::Errno::E_INVAL};
     }
-    if (write_buffer.size() < nfds * sizeof(PollFD)) {
-        return {-1, Errno::INVAL};
+    if (write_buffer.size() < nfds * sizeof(Network::PollFD)) {
+        return {-1, Network::Errno::E_INVAL};
     }
 
-    std::vector<PollFD> fds(nfds);
-    std::memcpy(fds.data(), read_buffer.data(), nfds * sizeof(PollFD));
+    std::span<const Network::PollFD> in_fds(reinterpret_cast<const Network::PollFD*>(read_buffer.data()), nfds);
+    std::span<Network::PollFD> out_fds(reinterpret_cast<Network::PollFD*>(write_buffer.data()), nfds);
+    std::copy(in_fds.begin(), in_fds.end(), out_fds.begin());
 
     if (timeout >= 0) {
         const s64 seconds = timeout / 1000;
-        const u64 nanoseconds = 1'000'000 * (static_cast<u64>(timeout) % 1000);
-
+        const u64 nanoseconds = 1'000'000 * (u64(timeout) % 1000);
         if (seconds < 0) {
-            return {-1, Errno::INVAL};
+            return {-1, Network::Errno::E_INVAL};
         }
         if (nanoseconds > 999'999'999) {
-            return {-1, Errno::INVAL};
+            return {-1, Network::Errno::E_INVAL};
         }
     } else if (timeout != -1) {
-        return {-1, Errno::INVAL};
+        return {-1, Network::Errno::E_INVAL};
     }
 
-    for (PollFD& pollfd : fds) {
-        ASSERT(False(pollfd.revents));
-
-        if (pollfd.fd > static_cast<s32>(MAX_FD) || pollfd.fd < 0) {
-            LOG_ERROR(Service, "File descriptor handle={} is invalid", pollfd.fd);
-            pollfd.revents = PollEvents{};
-            return {0, Errno::SUCCESS};
-        }
-
-        const std::optional<FileDescriptor>& descriptor = file_descriptors[pollfd.fd];
-        if (!descriptor) {
-            LOG_TRACE(Service, "File descriptor handle={} is not allocated", pollfd.fd);
-            pollfd.revents = PollEvents::Nval;
-            return {0, Errno::SUCCESS};
+    for (size_t i = 0; i < in_fds.size(); ++i) {
+        ASSERT(out_fds[i].fd == in_fds[i].fd && False(in_fds[i].revents));
+        if (!IsFileDescriptorValid(in_fds[i].fd)) {
+            out_fds[i].revents = {};
+            if (!file_descriptors[in_fds[i].fd])
+                out_fds[i].revents = Network::PollEvents::NVAL;
+            return {0, Network::Errno::E_SUCCESS};
         }
     }
 
-    std::vector<Network::PollFD> host_pollfds(fds.size());
-    std::transform(fds.begin(), fds.end(), host_pollfds.begin(), [](PollFD pollfd) {
-        Network::PollFD result;
-        result.socket = file_descriptors[pollfd.fd]->socket.get();
-        result.events = Translate(pollfd.events);
-        result.revents = Network::PollEvents{};
+    std::vector<Network::HostPollFD> host_pollfds(in_fds.size());
+    std::transform(in_fds.begin(), in_fds.end(), host_pollfds.begin(), [](auto const e) {
+        Network::HostPollFD result{};
+        result.socket = file_descriptors[e.fd]->socket.get();
+        result.events = e.events;
+        result.revents = {};
         return result;
     });
-
-    const auto result = Network::Poll(host_pollfds, timeout);
-
-    const size_t num = host_pollfds.size();
-    for (size_t i = 0; i < num; ++i) {
-        fds[i].revents = Translate(host_pollfds[i].revents);
-    }
-    std::memcpy(write_buffer.data(), fds.data(), nfds * sizeof(PollFD));
-
-    return Translate(result);
+    auto const res = Network::Poll(host_pollfds, timeout);
+    for (size_t i = 0; i < in_fds.size(); ++i)
+        out_fds[i].revents = host_pollfds[i].revents;
+    return res;
 }
 
-std::pair<s32, Errno> BSD_USA::AcceptImpl(s32 fd, std::vector<u8>& write_buffer) {
+std::pair<s32, Network::Errno> BSD_USA::AcceptImpl(s32 fd, std::vector<u8>& write_buffer) {
+    LOG_DEBUG(Network, "fd={}", fd);
     if (!IsFileDescriptorValid(fd)) {
-        return {-1, 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, 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) {
-        return {-1, Translate(bsd_errno)};
+    if (bsd_errno != Network::Errno::E_SUCCESS) {
+        return {-1, bsd_errno};
     }
 
     file_descriptors[new_fd] = FileDescriptor{};
@@ -654,267 +666,218 @@ std::pair<s32, Errno> BSD_USA::AcceptImpl(s32 fd, std::vector<u8>& write_buffer)
     new_descriptor.socket = std::move(result.socket);
     new_descriptor.is_connection_based = descriptor.is_connection_based;
 
-    const SockAddrIn guest_addr_in = Translate(result.sockaddr_in);
-    PutValue(write_buffer, guest_addr_in);
-
-    return {new_fd, Errno::SUCCESS};
+    PutValue(write_buffer, result.sockaddr_in);
+    return {new_fd, Network::Errno::E_SUCCESS};
 }
 
-Errno BSD_USA::BindImpl(s32 fd, std::span<const u8> addr) {
+Network::Errno BSD_USA::BindImpl(s32 fd, std::span<const u8> addr) {
+    LOG_DEBUG(Network, "fd={}", fd);
     if (!IsFileDescriptorValid(fd)) {
-        return Errno::BADF;
+        return Network::Errno::E_BADF;
     }
     ASSERT(addr.size() >= 16);
     if (!file_descriptors[fd]->socket) {
         LOG_WARNING(Service, "Uninitialized socket");
-        return Errno::BADF;
+        return Network::Errno::E_BADF;
     }
 
-    auto addr_in = GetValue<SockAddrIn>(addr);
-
-    return Translate(file_descriptors[fd]->socket->Bind(Translate(addr_in)));
+    auto addr_in = GetValue<Network::SockAddrIn>(addr);
+    return file_descriptors[fd]->socket->Bind(addr_in);
 }
 
-Errno BSD_USA::ConnectImpl(s32 fd, std::span<const u8> addr) {
+Network::Errno BSD_USA::ConnectImpl(s32 fd, std::span<const u8> addr) {
+    LOG_DEBUG(Network, "fd={}", fd);
     if (!IsFileDescriptorValid(fd)) {
-        return Errno::BADF;
+        return Network::Errno::E_BADF;
     }
 
     ASSERT(addr.size() >= 16);
     if (!file_descriptors[fd]->socket) {
         LOG_WARNING(Service, "Uninitialized socket");
-        return Errno::BADF;
+        return Network::Errno::E_BADF;
     }
 
-    auto addr_in = GetValue<SockAddrIn>(addr);
-
-    const Errno result = Translate(file_descriptors[fd]->socket->Connect(Translate(addr_in)));
-
-    if (result == Errno::ISCONN) {
+    auto addr_in = GetValue<Network::SockAddrIn>(addr);
+    const Network::Errno result = file_descriptors[fd]->socket->Connect(addr_in);
+    if (result == Network::Errno::E_ISCONN) {
         LOG_DEBUG(Service, "returned ISCONN - socket already connected");
-        return Errno::SUCCESS;
+        return Network::Errno::E_SUCCESS;
     }
 
     return result;
 }
 
-Errno BSD_USA::GetPeerNameImpl(s32 fd, std::vector<u8>& write_buffer) {
+Network::Errno BSD_USA::GetPeerNameImpl(s32 fd, std::vector<u8>& write_buffer) {
+    LOG_DEBUG(Network, "fd={}", fd);
     if (!IsFileDescriptorValid(fd)) {
-        return Errno::BADF;
+        return Network::Errno::E_BADF;
     }
 
     if (!file_descriptors[fd]->socket) {
         LOG_WARNING(Service, "Uninitialized socket");
-        return Errno::BADF;
+        return Network::Errno::E_BADF;
     }
 
     const auto [addr_in, bsd_errno] = file_descriptors[fd]->socket->GetPeerName();
-    if (bsd_errno != Network::Errno::SUCCESS) {
-        return Translate(bsd_errno);
+    if (bsd_errno != Network::Errno::E_SUCCESS) {
+        return bsd_errno;
     }
-    const SockAddrIn guest_addrin = Translate(addr_in);
-
-    ASSERT(write_buffer.size() >= sizeof(guest_addrin));
-    write_buffer.resize(sizeof(guest_addrin));
-    PutValue(write_buffer, guest_addrin);
-    return Translate(bsd_errno);
+    ASSERT(write_buffer.size() >= addr_in.len);
+    write_buffer.resize(addr_in.len);
+    PutValue(write_buffer, addr_in);
+    return bsd_errno;
 }
 
-Errno BSD_USA::GetSockNameImpl(s32 fd, std::vector<u8>& write_buffer) {
+Network::Errno BSD_USA::GetSockNameImpl(s32 fd, std::vector<u8>& write_buffer) {
+    LOG_DEBUG(Network, "fd={}", fd);
     if (!IsFileDescriptorValid(fd)) {
-        return Errno::BADF;
+        return Network::Errno::E_BADF;
     }
 
     if (!file_descriptors[fd]->socket) {
         LOG_WARNING(Service, "Uninitialized socket");
-        return Errno::BADF;
+        return Network::Errno::E_BADF;
     }
 
     const auto [addr_in, bsd_errno] = file_descriptors[fd]->socket->GetSockName();
-    if (bsd_errno != Network::Errno::SUCCESS) {
-        return Translate(bsd_errno);
+    if (bsd_errno != Network::Errno::E_SUCCESS) {
+        return bsd_errno;
     }
-    const SockAddrIn guest_addrin = Translate(addr_in);
-
-    ASSERT(write_buffer.size() >= sizeof(guest_addrin));
-    write_buffer.resize(sizeof(guest_addrin));
-    PutValue(write_buffer, guest_addrin);
-    return Translate(bsd_errno);
+    ASSERT(write_buffer.size() >= addr_in.len);
+    write_buffer.resize(addr_in.len);
+    PutValue(write_buffer, addr_in);
+    return bsd_errno;
 }
 
-Errno BSD_USA::ListenImpl(s32 fd, s32 backlog) {
+Network::Errno BSD_USA::ListenImpl(s32 fd, s32 backlog) {
+    LOG_DEBUG(Network, "fd={},backlog={}", fd, backlog);
     if (!IsFileDescriptorValid(fd)) {
-        return Errno::BADF;
+        return Network::Errno::E_BADF;
     }
     if (!file_descriptors[fd]->socket) {
         LOG_WARNING(Service, "Uninitialized socket");
-        return Errno::BADF;
+        return Network::Errno::E_BADF;
     }
-    return Translate(file_descriptors[fd]->socket->Listen(backlog));
+    return file_descriptors[fd]->socket->Listen(backlog);
 }
 
-std::pair<s32, Errno> BSD_USA::FcntlImpl(s32 fd, FcntlCmd cmd, s32 arg) {
+std::pair<s32, Network::Errno> BSD_USA::FcntlImpl(s32 fd, Network::FcntlCmd cmd, s32 arg) {
+    LOG_DEBUG(Network, "fd={},cmd={},arg={}", fd, u32(cmd), arg);
     if (!IsFileDescriptorValid(fd)) {
-        return {-1, Errno::BADF};
+        return {-1, Network::Errno::E_BADF};
     }
     if (!file_descriptors[fd]->socket) {
         LOG_WARNING(Service, "Uninitialized socket");
-        return {-1, Errno::BADF};
+        return {-1, Network::Errno::E_BADF};
     }
 
     FileDescriptor& descriptor = *file_descriptors[fd];
-
     switch (cmd) {
-    case FcntlCmd::GETFL:
+    case Network::FcntlCmd::GETFL:
         ASSERT(arg == 0);
-        return {descriptor.flags, Errno::SUCCESS};
-    case FcntlCmd::SETFL: {
-        const bool enable = (arg & Network::FLAG_O_NONBLOCK) != 0;
-        const Errno bsd_errno = Translate(descriptor.socket->SetNonBlock(enable));
-        if (bsd_errno != 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::E_SUCCESS) {
             return {-1, bsd_errno};
         }
         descriptor.flags = arg;
-        return {0, Errno::SUCCESS};
+        return {0, Network::Errno::E_SUCCESS};
     }
     default:
         UNIMPLEMENTED_MSG("Unimplemented cmd={}", cmd);
-        return {-1, Errno::SUCCESS};
+        return {-1, Network::Errno::E_SUCCESS};
     }
 }
 
-Errno BSD_USA::GetSockOptImpl(s32 fd, u32 level, OptName optname, std::vector<u8>& optval) {
+Network::Errno BSD_USA::GetSockOptImpl(s32 fd, Network::SocketLevel level, Network::OptName optname, std::vector<u8>& optval) {
+    LOG_DEBUG(Network, "fd={},level={},optname={}", fd, u32(level), u32(optname));
     if (!IsFileDescriptorValid(fd)) {
-        return Errno::BADF;
+        return Network::Errno::E_BADF;
     }
     if (!file_descriptors[fd]->socket) {
         LOG_WARNING(Service, "Uninitialized socket");
-        return Errno::BADF;
+        return Network::Errno::E_BADF;
     }
 
-    if (level != static_cast<u32>(SocketLevel::SOCKET)) {
-        UNIMPLEMENTED_MSG("Unknown getsockopt level");
-        return Errno::SUCCESS;
+    if (level != Network::SocketLevel::SOCKET) {
+        LOG_WARNING(Service, "(stubbed) level fd={}, level={}, optname={}", fd, level, optname);
     }
 
     Network::SocketBase* const socket = file_descriptors[fd]->socket.get();
 
     switch (optname) {
-    case OptName::ERROR_: {
+    case Network::OptName::ERROR_: {
         auto [pending_err, getsockopt_err] = socket->GetPendingError();
-        if (getsockopt_err == Network::Errno::SUCCESS) {
-            Errno translated_pending_err = Translate(pending_err);
+        if (getsockopt_err == Network::Errno::E_SUCCESS) {
             ASSERT_OR_EXECUTE_MSG(
-                optval.size() == sizeof(Errno), { return Errno::INVAL; },
+                optval.size() == sizeof(Network::Errno), { return Network::Errno::E_INVAL; },
                 "Incorrect getsockopt option size");
-            optval.resize(sizeof(Errno));
-            PutValue(optval, translated_pending_err);
+            optval.resize(sizeof(Network::Errno));
+            PutValue(optval, pending_err);
         }
-        return Translate(getsockopt_err);
+        return getsockopt_err;
     }
     default:
         UNIMPLEMENTED_MSG("Unimplemented optname={}", optname);
-        return Errno::SUCCESS;
+        return Network::Errno::E_SUCCESS;
     }
 }
 
-Errno BSD_USA::SetSockOptImpl(s32 fd, u32 level, OptName optname, std::span<const u8> optval) {
+Network::Errno BSD_USA::SetSockOptImpl(s32 fd, Network::SocketLevel level, Network::OptName optname, std::span<const u8> optval) {
+    LOG_DEBUG(Service, "fd={},level={},optname={}", fd, level, optname);
     if (!IsFileDescriptorValid(fd)) {
-        return Errno::BADF;
+        return Network::Errno::E_BADF;
     }
     if (!file_descriptors[fd]->socket) {
         LOG_WARNING(Service, "Uninitialized socket");
-        return Errno::BADF;
-    }
-
-    if (level != static_cast<u32>(SocketLevel::SOCKET)) {
-        LOG_WARNING(Service, "(STUBBED) setsockopt with level={}, optname={}", level, optname);
-        return Errno::SUCCESS;
+        return Network::Errno::E_BADF;
     }
 
     Network::SocketBase* const socket = file_descriptors[fd]->socket.get();
-
-    if (optname == OptName::LINGER) {
-        ASSERT(optval.size() == sizeof(Linger));
-        auto linger = GetValue<Linger>(optval);
-        ASSERT(linger.onoff == 0 || linger.onoff == 1);
-
-        return Translate(socket->SetLinger(linger.onoff != 0, linger.linger));
-    }
-
-    ASSERT(optval.size() == sizeof(u32));
-    auto value = GetValue<u32>(optval);
-
-    switch (optname) {
-    case OptName::REUSEADDR:
-        ASSERT(value == 0 || value == 1);
-        return Translate(socket->SetReuseAddr(value != 0));
-    case OptName::KEEPALIVE:
-        ASSERT(value == 0 || value == 1);
-        return Translate(socket->SetKeepAlive(value != 0));
-    case OptName::BROADCAST:
-        ASSERT(value == 0 || value == 1);
-        return Translate(socket->SetBroadcast(value != 0));
-    case OptName::SNDBUF:
-        return Translate(socket->SetSndBuf(value));
-    case OptName::RCVBUF:
-        return Translate(socket->SetRcvBuf(value));
-    case OptName::SNDTIMEO:
-        return Translate(socket->SetSndTimeo(value));
-    case OptName::RCVTIMEO:
-        return Translate(socket->SetRcvTimeo(value));
-    case OptName::NOSIGPIPE:
-        LOG_WARNING(Service, "(STUBBED) setting NOSIGPIPE to {}", value);
-        return Errno::SUCCESS;
-    default:
-        UNIMPLEMENTED_MSG("Unimplemented optname={}", optname);
-        return Errno::SUCCESS;
-    }
+    return socket->SetSockOpt(level, optname, optval);
 }
 
-Errno BSD_USA::ShutdownImpl(s32 fd, s32 how) {
+Network::Errno BSD_USA::ShutdownImpl(s32 fd, s32 how) {
+    LOG_DEBUG(Network, "fd={},how={}", fd, how);
     if (!IsFileDescriptorValid(fd)) {
-        return Errno::BADF;
+        return Network::Errno::E_BADF;
     }
     if (!file_descriptors[fd]->socket) {
         LOG_WARNING(Service, "Uninitialized socket");
-        return Errno::BADF;
+        return Network::Errno::E_BADF;
     }
-    const Network::ShutdownHow host_how = Translate(static_cast<ShutdownHow>(how));
-    return Translate(file_descriptors[fd]->socket->Shutdown(host_how));
+    return file_descriptors[fd]->socket->Shutdown(Network::ShutdownHow(how));
 }
 
-std::pair<s32, Errno> BSD_USA::RecvImpl(s32 fd, u32 flags, std::vector<u8>& message) {
+std::pair<s32, Network::Errno> BSD_USA::RecvImpl(s32 fd, u32 flags, std::vector<u8>& message) {
+    LOG_DEBUG(Network, "fd={},flags={}", fd, flags);
     if (!IsFileDescriptorValid(fd)) {
-        return {-1, Errno::BADF};
+        return {-1, Network::Errno::E_BADF};
     }
 
     FileDescriptor& descriptor = *file_descriptors[fd];
 
     // Apply flags
-    using Network::FLAG_MSG_DONTWAIT;
-    using Network::FLAG_O_NONBLOCK;
-    if ((flags & FLAG_MSG_DONTWAIT) != 0) {
-        flags &= ~FLAG_MSG_DONTWAIT;
-        if ((descriptor.flags & FLAG_O_NONBLOCK) == 0) {
+    if ((flags & u32(Network::MsgOpt::DONTWAIT)) != 0) {
+        flags &= ~u32(Network::MsgOpt::DONTWAIT);
+        if ((descriptor.flags & u32(Network::FcntlFlags::NONBLOCK_NX)) == 0) {
             descriptor.socket->SetNonBlock(true);
         }
     }
 
-    const auto [ret, bsd_errno] = Translate(descriptor.socket->Recv(flags, message));
-
+    const auto [ret, bsd_errno] = descriptor.socket->Recv(flags, message);
     // Restore original state
-    if ((descriptor.flags & FLAG_O_NONBLOCK) == 0) {
+    if ((descriptor.flags & u32(Network::FcntlFlags::NONBLOCK_NX)) == 0)
         descriptor.socket->SetNonBlock(false);
-    }
-
     return {ret, bsd_errno};
 }
 
-std::pair<s32, Errno> BSD_USA::RecvFromImpl(s32 fd, u32 flags, std::vector<u8>& message,
-                                        std::vector<u8>& addr) {
+std::pair<s32, Network::Errno> BSD_USA::RecvFromImpl(s32 fd, u32 flags, std::vector<u8>& message, std::vector<u8>& addr) {
+    LOG_DEBUG(Network, "fd={},flags={}", fd, flags);
     if (!IsFileDescriptorValid(fd)) {
-        return {-1, Errno::BADF};
+        return {-1, Network::Errno::E_BADF};
     }
 
     FileDescriptor& descriptor = *file_descriptors[fd];
@@ -929,19 +892,17 @@ std::pair<s32, Errno> BSD_USA::RecvFromImpl(s32 fd, u32 flags, std::vector<u8>&
     }
 
     // Apply flags
-    using Network::FLAG_MSG_DONTWAIT;
-    using Network::FLAG_O_NONBLOCK;
-    if ((flags & FLAG_MSG_DONTWAIT) != 0) {
-        flags &= ~FLAG_MSG_DONTWAIT;
-        if ((descriptor.flags & FLAG_O_NONBLOCK) == 0) {
+    if ((flags & u32(Network::MsgOpt::DONTWAIT)) != 0) {
+        flags &= ~u32(Network::MsgOpt::DONTWAIT);
+        if ((descriptor.flags & u32(Network::FcntlFlags::NONBLOCK_NX)) == 0) {
             descriptor.socket->SetNonBlock(true);
         }
     }
 
-    const auto [ret, bsd_errno] = Translate(descriptor.socket->RecvFrom(flags, message, p_addr_in));
+    const auto [ret, bsd_errno] = descriptor.socket->RecvFrom(flags, message, p_addr_in);
 
     // Restore original state
-    if ((descriptor.flags & FLAG_O_NONBLOCK) == 0) {
+    if ((descriptor.flags & u32(Network::FcntlFlags::NONBLOCK_NX)) == 0) {
         descriptor.socket->SetNonBlock(false);
     }
 
@@ -950,58 +911,59 @@ std::pair<s32, Errno> BSD_USA::RecvFromImpl(s32 fd, u32 flags, std::vector<u8>&
             addr.clear();
         } else {
             ASSERT(addr.size() >= 16);
-            const SockAddrIn result = Translate(addr_in);
-            PutValue(addr, result);
+            PutValue(addr, addr_in);
         }
     }
 
     return {ret, bsd_errno};
 }
 
-std::pair<s32, Errno> BSD_USA::SendImpl(s32 fd, u32 flags, std::span<const u8> message) {
+std::pair<s32, Network::Errno> BSD_USA::SendImpl(s32 fd, u32 flags, std::span<const u8> message) {
+    LOG_DEBUG(Network, "fd={},flags={}", fd, flags);
     if (!IsFileDescriptorValid(fd)) {
-        return {-1, Errno::BADF};
+        return {-1, Network::Errno::E_BADF};
     }
     if (!file_descriptors[fd]->socket) {
         LOG_WARNING(Service, "Uninitialized socket");
-        return {-1, Errno::BADF};
+        return {-1, Network::Errno::E_BADF};
     }
-    return Translate(file_descriptors[fd]->socket->Send(message, flags));
+    return file_descriptors[fd]->socket->Send(message, flags);
 }
 
-std::pair<s32, Errno> BSD_USA::SendToImpl(s32 fd, u32 flags, std::span<const u8> message,
-                                      std::span<const u8> addr) {
+std::pair<s32, Network::Errno> BSD_USA::SendToImpl(s32 fd, u32 flags, std::span<const u8> message, std::span<const u8> addr) {
+    LOG_DEBUG(Network, "fd={},flags={}", fd, flags);
     if (!IsFileDescriptorValid(fd)) {
-        return {-1, Errno::BADF};
+        return {-1, Network::Errno::E_BADF};
     }
     if (!file_descriptors[fd]->socket) {
         LOG_WARNING(Service, "Uninitialized socket");
-        return {-1, Errno::BADF};
+        return {-1, Network::Errno::E_BADF};
     }
 
-    Network::SockAddrIn addr_in;
+    Network::SockAddrIn addr_in{};
     Network::SockAddrIn* p_addr_in = nullptr;
     if (!addr.empty()) {
         ASSERT(addr.size() >= 16);
-        auto guest_addr_in = GetValue<SockAddrIn>(addr);
-        addr_in = Translate(guest_addr_in);
+        auto guest_addr_in = GetValue<Network::SockAddrIn>(addr);
+        addr_in = guest_addr_in;
         p_addr_in = &addr_in;
     }
 
-    return Translate(file_descriptors[fd]->socket->SendTo(flags, message, p_addr_in));
+    return file_descriptors[fd]->socket->SendTo(flags, message, p_addr_in);
 }
 
-Errno BSD_USA::CloseImpl(s32 fd) {
+Network::Errno BSD_USA::CloseImpl(s32 fd) {
+    LOG_DEBUG(Network, "fd={}", fd);
     if (!IsFileDescriptorValid(fd)) {
-        return Errno::BADF;
+        return Network::Errno::E_BADF;
     }
     if (!file_descriptors[fd]->socket) {
         LOG_WARNING(Service, "Uninitialized socket");
-        return Errno::BADF;
+        return Network::Errno::E_BADF;
     }
 
-    const Errno bsd_errno = Translate(file_descriptors[fd]->socket->Close());
-    if (bsd_errno != Errno::SUCCESS) {
+    auto const bsd_errno = file_descriptors[fd]->socket->Close();
+    if (bsd_errno != Network::Errno::E_SUCCESS) {
         return bsd_errno;
     }
 
@@ -1011,15 +973,16 @@ Errno BSD_USA::CloseImpl(s32 fd) {
     return bsd_errno;
 }
 
-std::variant<s32, Errno> BSD_USA::DuplicateSocketImpl(s32 fd) {
+std::variant<s32, Network::Errno> BSD_USA::DuplicateSocketImpl(s32 fd) {
+    LOG_DEBUG(Network, "fd={}", fd);
     if (!IsFileDescriptorValid(fd)) {
-        return Errno::BADF;
+        return Network::Errno::E_BADF;
     }
 
     const s32 new_fd = FindFreeFileDescriptorHandle();
-    if (new_fd < 0) {
+    if (!IsFileDescriptorValid(new_fd)) {
         LOG_ERROR(Service, "No more file descriptors available");
-        return Errno::MFILE;
+        return Network::Errno::E_MFILE;
     }
 
     file_descriptors[new_fd] = FileDescriptor{
@@ -1031,6 +994,7 @@ std::variant<s32, Errno> BSD_USA::DuplicateSocketImpl(s32 fd) {
 }
 
 std::optional<std::shared_ptr<Network::SocketBase>> BSD_USA::GetSocket(s32 fd) {
+    LOG_DEBUG(Network, "fd={}", fd);
     if (!IsFileDescriptorValid(fd)) {
         return std::nullopt;
     }
@@ -1042,41 +1006,40 @@ std::optional<std::shared_ptr<Network::SocketBase>> BSD_USA::GetSocket(s32 fd) {
 }
 
 s32 BSD_USA::FindFreeFileDescriptorHandle() noexcept {
-    for (s32 fd = 0; fd < static_cast<s32>(file_descriptors.size()); ++fd) {
-        if (!file_descriptors[fd]) {
+    // first three file descriptors are reserved for:
+    // STDOUT_FILENO, STDIN_FILENO and STDERR_FILENO
+    for (s32 fd = 0; fd < s32(file_descriptors.size()); ++fd)
+        if (!file_descriptors[fd])
             return fd;
-        }
-    }
     return -1;
 }
 
 bool BSD_USA::IsFileDescriptorValid(s32 fd) const noexcept {
-    if (fd > static_cast<s32>(MAX_FD) || fd < 0) {
-        LOG_ERROR(Service, "Invalid file descriptor handle={}", fd);
+    if (fd < 0 || fd >= s32(file_descriptors.size())) {
+        LOG_ERROR(Service, "Invalid handle={}", fd);
         return false;
     }
     if (!file_descriptors[fd]) {
-        LOG_ERROR(Service, "File descriptor handle={} is not allocated", fd);
+        LOG_ERROR(Service, "handle={} is not allocated", fd);
         return false;
     }
     return true;
 }
 
-void BSD_USA::BuildErrnoResponse(HLERequestContext& ctx, Errno bsd_errno) const noexcept {
+void BSD_USA::BuildErrnoResponse(HLERequestContext& ctx, Network::Errno bsd_errno) const noexcept {
     IPC::ResponseBuilder rb{ctx, 4};
 
     rb.Push(ResultSuccess);
-    rb.Push<s32>(bsd_errno == Errno::SUCCESS ? 0 : -1);
+    rb.Push<s32>(bsd_errno == Network::Errno::E_SUCCESS ? 0 : -1);
     rb.PushEnum(bsd_errno);
 }
 
 void BSD_USA::OnProxyPacketReceived(const Network::ProxyPacket& packet) {
     for (auto& optional_descriptor : file_descriptors) {
-        if (!optional_descriptor.has_value()) {
-            continue;
+        if (optional_descriptor.has_value()) {
+            FileDescriptor& descriptor = *optional_descriptor;
+            descriptor.socket.get()->HandleProxyPacket(packet);
         }
-        FileDescriptor& descriptor = *optional_descriptor;
-        descriptor.socket.get()->HandleProxyPacket(packet);
     }
 }
 

src/core/hle/service/sockets/bsd.h

@@ -11,7 +11,7 @@
 #include <variant>
 
 #include "common/common_types.h"
-#include "common/socket_types.h"
+#include "core/internal_network/socket_types.h"
 #include "core/hle/service/service.h"
 #include "core/hle/service/sockets/sockets.h"
 #include "network/network.h"
@@ -35,8 +35,8 @@ public:
     // These methods are called from SSL; the first two are also called from
     // this class for the corresponding IPC methods.
     // On the real device, the SSL service makes IPC calls to this service.
-    std::variant<s32, Errno> DuplicateSocketImpl(s32 fd);
-    Errno CloseImpl(s32 fd);
+    std::variant<s32, Network::Errno> DuplicateSocketImpl(s32 fd);
+    Network::Errno CloseImpl(s32 fd);
     std::optional<std::shared_ptr<Network::SocketBase>> GetSocket(s32 fd);
 
 private:
@@ -58,7 +58,7 @@ private:
         std::span<const u8> read_buffer;
         std::vector<u8> write_buffer;
         s32 ret{};
-        Errno bsd_errno{};
+        Network::Errno bsd_errno{};
     };
 
     struct AcceptWork {
@@ -68,7 +68,7 @@ private:
         s32 fd;
         std::vector<u8> write_buffer;
         s32 ret{};
-        Errno bsd_errno{};
+        Network::Errno bsd_errno{};
     };
 
     struct ConnectWork {
@@ -77,7 +77,7 @@ private:
 
         s32 fd;
         std::span<const u8> addr;
-        Errno bsd_errno{};
+        Network::Errno bsd_errno{};
     };
 
     struct RecvWork {
@@ -88,7 +88,7 @@ private:
         u32 flags;
         std::vector<u8> message;
         s32 ret{};
-        Errno bsd_errno{};
+        Network::Errno bsd_errno{};
     };
 
     struct RecvFromWork {
@@ -100,7 +100,7 @@ private:
         std::vector<u8> message;
         std::vector<u8> addr;
         s32 ret{};
-        Errno bsd_errno{};
+        Network::Errno bsd_errno{};
     };
 
     struct SendWork {
@@ -111,7 +111,7 @@ private:
         u32 flags;
         std::span<const u8> message;
         s32 ret{};
-        Errno bsd_errno{};
+        Network::Errno bsd_errno{};
     };
 
     struct SendToWork {
@@ -123,7 +123,7 @@ private:
         std::span<const u8> message;
         std::span<const u8> addr;
         s32 ret{};
-        Errno bsd_errno{};
+        Network::Errno bsd_errno{};
     };
 
     void RegisterClient(HLERequestContext& ctx);
@@ -155,29 +155,29 @@ private:
     template <typename Work>
     void ExecuteWork(HLERequestContext& ctx, Work work);
 
-    std::pair<s32, Errno> SocketImpl(Domain domain, Type type, Protocol protocol);
-    std::pair<s32, Errno> PollImpl(std::vector<u8>& write_buffer, std::span<const u8> read_buffer, s32 nfds, s32 timeout);
-    std::pair<s32, Errno> AcceptImpl(s32 fd, std::vector<u8>& write_buffer);
-    Errno BindImpl(s32 fd, std::span<const u8> addr);
-    Errno ConnectImpl(s32 fd, std::span<const u8> addr);
-    Errno GetPeerNameImpl(s32 fd, std::vector<u8>& write_buffer);
-    Errno GetSockNameImpl(s32 fd, std::vector<u8>& write_buffer);
-    Errno ListenImpl(s32 fd, s32 backlog);
-    std::pair<s32, Errno> FcntlImpl(s32 fd, FcntlCmd cmd, s32 arg);
-    Errno GetSockOptImpl(s32 fd, u32 level, OptName optname, std::vector<u8>& optval);
-    Errno SetSockOptImpl(s32 fd, u32 level, OptName optname, std::span<const u8> optval);
-    Errno ShutdownImpl(s32 fd, s32 how);
-    std::pair<s32, Errno> RecvImpl(s32 fd, u32 flags, std::vector<u8>& message);
-    std::pair<s32, Errno> RecvFromImpl(s32 fd, u32 flags, std::vector<u8>& message,
+    std::pair<s32, Network::Errno> SocketImpl(Network::Domain domain, Network::Type type, Network::Protocol protocol);
+    std::pair<s32, Network::Errno> PollImpl(std::vector<u8>& write_buffer, std::span<const u8> read_buffer, s32 nfds, s32 timeout);
+    std::pair<s32, Network::Errno> AcceptImpl(s32 fd, std::vector<u8>& write_buffer);
+    Network::Errno BindImpl(s32 fd, std::span<const u8> addr);
+    Network::Errno ConnectImpl(s32 fd, std::span<const u8> addr);
+    Network::Errno GetPeerNameImpl(s32 fd, std::vector<u8>& write_buffer);
+    Network::Errno GetSockNameImpl(s32 fd, std::vector<u8>& write_buffer);
+    Network::Errno ListenImpl(s32 fd, s32 backlog);
+    std::pair<s32, Network::Errno> FcntlImpl(s32 fd, Network::FcntlCmd cmd, s32 arg);
+    Network::Errno GetSockOptImpl(s32 fd, Network::SocketLevel level, Network::OptName optname, std::vector<u8>& optval);
+    Network::Errno SetSockOptImpl(s32 fd, Network::SocketLevel level, Network::OptName optname, std::span<const u8> optval);
+    Network::Errno ShutdownImpl(s32 fd, s32 how);
+    std::pair<s32, Network::Errno> RecvImpl(s32 fd, u32 flags, std::vector<u8>& message);
+    std::pair<s32, Network::Errno> RecvFromImpl(s32 fd, u32 flags, std::vector<u8>& message,
                                        std::vector<u8>& addr);
-    std::pair<s32, Errno> SendImpl(s32 fd, u32 flags, std::span<const u8> message);
-    std::pair<s32, Errno> SendToImpl(s32 fd, u32 flags, std::span<const u8> message,
+    std::pair<s32, Network::Errno> SendImpl(s32 fd, u32 flags, std::span<const u8> message);
+    std::pair<s32, Network::Errno> SendToImpl(s32 fd, u32 flags, std::span<const u8> message,
                                      std::span<const u8> addr);
 
     s32 FindFreeFileDescriptorHandle() noexcept;
     bool IsFileDescriptorValid(s32 fd) const noexcept;
 
-    void BuildErrnoResponse(HLERequestContext& ctx, Errno bsd_errno) const noexcept;
+    void BuildErrnoResponse(HLERequestContext& ctx, Network::Errno bsd_errno) const noexcept;
 
     static inline std::array<std::optional<FileDescriptor>, MAX_FD> file_descriptors{};
 

src/core/hle/service/sockets/sfdnsres.cpp

@@ -102,39 +102,39 @@ static bool IsBlockedHost(const std::string& host) {
         [&host](const std::string& domain) { return host.find(domain) != std::string::npos; });
 }
 
-static NetDbError GetAddrInfoErrorToNetDbError(GetAddrInfoError result) {
+static NetDbError GetAddrInfoErrorToNetDbError(Network::GetAddrInfoError result) {
     // These combinations have been verified on console (but are not
     // exhaustive).
     switch (result) {
-    case GetAddrInfoError::SUCCESS:
+    case Network::GetAddrInfoError::SUCCESS:
         return NetDbError::Success;
-    case GetAddrInfoError::AGAIN:
+    case Network::GetAddrInfoError::AGAIN:
         return NetDbError::TryAgain;
-    case GetAddrInfoError::NODATA:
+    case Network::GetAddrInfoError::NODATA:
         return NetDbError::HostNotFound;
-    case GetAddrInfoError::SERVICE:
+    case Network::GetAddrInfoError::SERVICE:
         return NetDbError::Success;
     default:
         return NetDbError::HostNotFound;
     }
 }
 
-static Errno GetAddrInfoErrorToErrno(GetAddrInfoError result) {
+static Network::Errno GetAddrInfoErrorToErrno(Network::GetAddrInfoError result) {
     // These combinations have been verified on console (but are not
     // exhaustive).
     switch (result) {
-    case GetAddrInfoError::SUCCESS:
+    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 Errno::SUCCESS;
-    case GetAddrInfoError::AGAIN:
-        return Errno::SUCCESS;
-    case GetAddrInfoError::NODATA:
-        return Errno::SUCCESS;
-    case GetAddrInfoError::SERVICE:
-        return Errno::INVAL;
+        return Network::Errno::E_SUCCESS;
+    case Network::GetAddrInfoError::AGAIN:
+        return Network::Errno::E_SUCCESS;
+    case Network::GetAddrInfoError::NODATA:
+        return Network::Errno::E_SUCCESS;
+    case Network::GetAddrInfoError::SERVICE:
+        return Network::Errno::E_INVAL;
     default:
-        return Errno::SUCCESS;
+        return Network::Errno::E_SUCCESS;
     }
 }
 
@@ -155,9 +155,7 @@ static void AppendNulTerminated(std::vector<u8>& vec, std::string_view str) {
 // host's gethostbyname, because it simplifies portability: e.g., getaddrinfo
 // behaves the same on Unix and Windows, unlike gethostbyname where Windows
 // doesn't implement h_errno.
-static std::vector<u8> SerializeAddrInfoAsHostEnt(const std::vector<Network::AddrInfo>& vec,
-                                                  std::string_view host) {
-
+static std::vector<u8> SerializeAddrInfoAsHostEnt(std::span<const Network::AddrInfo> vec, std::string_view host) {
     std::vector<u8> data;
     // h_name: use the input hostname (append nul-terminated)
     AppendNulTerminated(data, host);
@@ -165,12 +163,12 @@ static std::vector<u8> SerializeAddrInfoAsHostEnt(const std::vector<Network::Add
 
     Append<u32_be>(data, 0); // count of h_aliases
     // (If the count were nonzero, the aliases would be appended as nul-terminated here.)
-    Append<u16_be>(data, static_cast<u16>(Domain::INET)); // h_addrtype
+    Append<u16_be>(data, u16(Network::Domain::INET)); // h_addrtype
     Append<u16_be>(data, sizeof(Network::IPv4Address));   // h_length
     // h_addr_list:
     size_t count = vec.size();
     ASSERT(count <= UINT32_MAX);
-    Append<u32_be>(data, static_cast<uint32_t>(count));
+    Append<u32_be>(data, u32(count));
     for (const Network::AddrInfo& addrinfo : vec) {
         // On the Switch, this is passed through htonl despite already being
         // big-endian, so it ends up as little-endian.
@@ -182,7 +180,7 @@ static std::vector<u8> SerializeAddrInfoAsHostEnt(const std::vector<Network::Add
     return data;
 }
 
-static std::pair<u32, GetAddrInfoError> GetHostByNameRequestImpl(HLERequestContext& ctx) {
+static std::pair<u32, Network::GetAddrInfoError> GetHostByNameRequestImpl(HLERequestContext& ctx) {
     struct InputParameters {
         u8 use_nsd_resolve;
         u32 cancel_handle;
@@ -205,7 +203,7 @@ static std::pair<u32, GetAddrInfoError> GetHostByNameRequestImpl(HLERequestConte
     // Prevent resolution of Nintendo servers
     if (IsBlockedHost(host)) {
         LOG_WARNING(Network, "Resolution of hostname {} requested, returning EAI_AGAIN", host);
-        return {0, GetAddrInfoError::AGAIN};
+        return {0, Network::GetAddrInfoError::AGAIN};
     }
 
     auto res_v = Network::GetAddressInfo(host, /*service*/ std::nullopt);
@@ -213,10 +211,10 @@ static std::pair<u32, GetAddrInfoError> GetHostByNameRequestImpl(HLERequestConte
         const std::vector<u8> data = SerializeAddrInfoAsHostEnt(*res, host);
         const u32 data_size = u32(data.size());
         ctx.WriteBuffer(data, 0);
-        return {data_size, GetAddrInfoError::SUCCESS};
+        return {data_size, Network::GetAddrInfoError::SUCCESS};
     }
     auto* err = std::get_if<Network::GetAddrInfoError>(&res_v);
-    return {0, Translate(*err)};
+    return {0, *err};
 }
 
 void SFDNSRES::GetHostByNameRequest(HLERequestContext& ctx) {
@@ -224,7 +222,7 @@ void SFDNSRES::GetHostByNameRequest(HLERequestContext& ctx) {
 
     struct OutputParameters {
         NetDbError netdb_error;
-        Errno bsd_errno;
+        Network::Errno bsd_errno;
         u32 data_size;
     };
     static_assert(sizeof(OutputParameters) == 0xc);
@@ -244,7 +242,7 @@ void SFDNSRES::GetHostByNameRequestWithOptions(HLERequestContext& ctx) {
     struct OutputParameters {
         u32 data_size;
         NetDbError netdb_error;
-        Errno bsd_errno;
+        Network::Errno bsd_errno;
     };
     static_assert(sizeof(OutputParameters) == 0xc);
 
@@ -257,24 +255,23 @@ void SFDNSRES::GetHostByNameRequestWithOptions(HLERequestContext& ctx) {
     });
 }
 
-static std::vector<u8> SerializeAddrInfo(const std::vector<Network::AddrInfo>& vec,
-                                         std::string_view host) {
+static std::vector<u8> SerializeAddrInfo(std::span<const Network::AddrInfo> vec, std::string_view host) {
     // Adapted from
     // https://github.com/switchbrew/libnx/blob/c5a9a909a91657a9818a3b7e18c9b91ff0cbb6e3/nx/source/runtime/resolver.c#L190
     std::vector<u8> data;
 
     for (const Network::AddrInfo& addrinfo : vec) {
         // serialized addrinfo:
-        Append<u32_be>(data, 0xBEEFCAFE);                                        // magic
-        Append<u32_be>(data, 0);                                                 // ai_flags
-        Append<u32_be>(data, static_cast<u32>(Translate(addrinfo.family)));      // ai_family
-        Append<u32_be>(data, static_cast<u32>(Translate(addrinfo.socket_type))); // ai_socktype
-        Append<u32_be>(data, static_cast<u32>(Translate(addrinfo.protocol)));    // ai_protocol
+        Append<u32_be>(data, 0xBEEFCAFE); // magic
+        Append<u32_be>(data, 0); // ai_flags
+        Append<u32_be>(data, u32(addrinfo.family));      // ai_family
+        Append<u32_be>(data, u32(addrinfo.socket_type)); // ai_socktype
+        Append<u32_be>(data, u32(addrinfo.protocol));    // ai_protocol
         Append<u32_be>(data, 16); // ai_addrlen
         // ^ *not* sizeof(SerializedSockAddrIn), not that it matters since they're the same size
 
         // ai_addr:
-        Append<u16_be>(data, static_cast<u16>(Translate(addrinfo.addr.family))); // sin_family
+        Append<u16_be>(data, u16(addrinfo.addr.family)); // sin_family
         // On the Switch, the following fields are passed through htonl despite
         // already being big-endian, so they end up as little-endian.
         Append<u16_le>(data, addrinfo.addr.portno);                            // sin_port
@@ -296,7 +293,7 @@ static std::vector<u8> SerializeAddrInfo(const std::vector<Network::AddrInfo>& v
     return data;
 }
 
-static std::pair<u32, GetAddrInfoError> GetAddrInfoRequestImpl(HLERequestContext& ctx) {
+static std::pair<u32, Network::GetAddrInfoError> GetAddrInfoRequestImpl(HLERequestContext& ctx) {
     struct InputParameters {
         u8 use_nsd_resolve;
         u32 cancel_handle;
@@ -321,7 +318,7 @@ static std::pair<u32, GetAddrInfoError> GetAddrInfoRequestImpl(HLERequestContext
     // Prevent resolution of Nintendo servers
     if (IsBlockedHost(host)) {
         LOG_WARNING(Network, "Resolution of hostname {} requested, returning EAI_AGAIN", host);
-        return {0, GetAddrInfoError::AGAIN};
+        return {0, Network::GetAddrInfoError::AGAIN};
     }
 
     std::optional<std::string> service = std::nullopt;
@@ -331,24 +328,23 @@ static std::pair<u32, GetAddrInfoError> GetAddrInfoRequestImpl(HLERequestContext
     }
 
     // Serialized hints are also passed in a buffer, but are ignored for now.
-
     auto res_v = Network::GetAddressInfo(host, service);
     if (auto* res = std::get_if<std::vector<Network::AddrInfo>>(&res_v)) {
         const std::vector<u8> data = SerializeAddrInfo(*res, host);
         const u32 data_size = u32(data.size());
         ctx.WriteBuffer(data, 0);
-        return {data_size, GetAddrInfoError::SUCCESS};
+        return {data_size, Network::GetAddrInfoError::SUCCESS};
     }
     auto* err = std::get_if<Network::GetAddrInfoError>(&res_v);
-    return {0, Translate(*err)};
+    return {0, *err};
 }
 
 void SFDNSRES::GetAddrInfoRequest(HLERequestContext& ctx) {
     auto [data_size, emu_gai_err] = GetAddrInfoRequestImpl(ctx);
 
     struct OutputParameters {
-        Errno bsd_errno;
-        GetAddrInfoError gai_error;
+        Network::Errno bsd_errno;
+        Network::GetAddrInfoError gai_error;
         u32 data_size;
     };
     static_assert(sizeof(OutputParameters) == 0xc);
@@ -364,7 +360,7 @@ void SFDNSRES::GetAddrInfoRequest(HLERequestContext& ctx) {
 
 void SFDNSRES::GetGaiStringErrorRequest(HLERequestContext& ctx) {
     struct InputParameters {
-        GetAddrInfoError gai_errno;
+        Network::GetAddrInfoError gai_errno;
     };
     IPC::RequestParser rp{ctx};
     auto input = rp.PopRaw<InputParameters>();
@@ -382,9 +378,9 @@ void SFDNSRES::GetAddrInfoRequestWithOptions(HLERequestContext& ctx) {
 
     struct OutputParameters {
         u32 data_size;
-        GetAddrInfoError gai_error;
+        Network::GetAddrInfoError gai_error;
         NetDbError netdb_error;
-        Errno bsd_errno;
+        Network::Errno bsd_errno;
     };
     static_assert(sizeof(OutputParameters) == 0x10);
 

src/core/hle/service/sockets/sockets.h

@@ -8,6 +8,7 @@
 
 #include "common/common_funcs.h"
 #include "common/common_types.h"
+#include "core/internal_network/socket_types.h"
 
 namespace Core {
 class System;
@@ -15,242 +16,6 @@ class System;
 
 namespace Service::Sockets {
 
-enum class Errno : u32 {
-    SUCCESS = 0,
-    BADF = 9,
-    AGAIN = 11,
-    INVAL = 22,
-    MFILE = 24,
-    PIPE = 32,
-    MSGSIZE = 90,
-    CONNABORTED = 103,
-    CONNRESET = 104,
-    NOTCONN = 107,
-    TIMEDOUT = 110,
-    CONNREFUSED = 111,
-    INPROGRESS = 115,
-    ISCONN = 106,
-};
-
-enum class GetAddrInfoError : s32 {
-    SUCCESS = 0,
-    ADDRFAMILY = 1,
-    AGAIN = 2,
-    BADFLAGS = 3,
-    FAIL = 4,
-    FAMILY = 5,
-    MEMORY = 6,
-    NODATA = 7,
-    NONAME = 8,
-    SERVICE = 9,
-    SOCKTYPE = 10,
-    SYSTEM = 11,
-    BADHINTS = 12,
-    PROTOCOL = 13,
-    OVERFLOW_ = 14, // avoid name collision with Windows macro
-    OTHER = 15,
-};
-
-enum class Domain : u32 {
-    Unspecified = 0,
-    INET = 2,
-};
-
-enum class Type : u32 {
-    Unspecified = 0,
-    STREAM = 1,
-    DGRAM = 2,
-    RAW = 3,
-    SEQPACKET = 5,
-};
-
-enum class Protocol : u32 {
-    IP = 0,
-    ICMP = 1,
-    TCP = 6,
-    UDP = 17,
-    //
-    IPV6 = 41,
-    RAW = 255,
-    //
-    HOPOPTS = 0,
-    IGMP = 2,
-    GGP = 3,
-    IPV4 = 4,
-    ST = 7,
-    EGP = 8,
-    PIGP = 9,
-    RCCMON = 10,
-    NVPII = 11,
-    PUP = 12,
-    ARGUS = 13,
-    EMCON = 14,
-    XNET = 15,
-    CHAOS = 16,
-    MUX = 18,
-    MEAS = 19,
-    HMP = 20,
-    PRM = 21,
-    IDP = 22,
-    TRUNK1 = 23,
-    TRUNK2 = 24,
-    LEAF1 = 25,
-    LEAF2 = 26,
-    RDP = 27,
-    IRTP = 28,
-    TP = 29,
-    BLT = 30,
-    NSP = 31,
-    INP = 32,
-    DCCP = 33,
-    //3PC = 34,
-    IDPR = 35,
-    XTP = 36,
-    DDP = 37,
-    CMTP = 38,
-    TPXX = 39,
-    IL = 40,
-    SDRP = 42,
-    ROUTING = 43,
-    FRAGMENT = 44,
-    IDRP = 45,
-    RSVP = 46,
-    GRE = 47,
-    MHRP = 48,
-    BHA = 49,
-    ESP = 50,
-    AH = 51,
-    INLSP = 52,
-    SWIPE = 53,
-    NHRP = 54,
-    MOBILE = 55,
-    TLSP = 56,
-    SKIP = 57,
-    ICMPV6 = 58,
-    NONE = 59,
-    DSTOPTS = 60,
-    AHIP = 61,
-    CFTP = 62,
-    HELLO = 63,
-    SATEXPAK = 64,
-    KRYPTOLAN = 65,
-    RVD = 66,
-    IPPC = 67,
-    ADFS = 68,
-    SATMON = 69,
-    VISA = 70,
-    IPCV = 71,
-    CPNX = 72,
-    CPHB = 73,
-    WSN = 74,
-    PVP = 75,
-    BRSATMON = 76,
-    ND = 77,
-    WBMON = 78,
-    WBEXPAK = 79,
-    EON = 80,
-    VMTP = 81,
-    SVMTP = 82,
-    VINES = 83,
-    TTP = 84,
-    IGP = 85,
-    DGP = 86,
-    TCF = 87,
-    IGRP = 88,
-    OSPFIGP = 89,
-    SRPC = 90,
-    LARP = 91,
-    MTP = 92,
-    AX25 = 93,
-    IPEIP = 94,
-    MICP = 95,
-    SCCSP = 96,
-    ETHERIP = 97,
-    ENCAP = 98,
-    APES = 99,
-    GMTP = 100,
-    IPCOMP = 108,
-    SCTP = 132,
-    MH = 135,
-    UDPLITE = 136,
-    HIP = 139,
-    SHIM6 = 140,
-    PIM = 103,
-    CARP = 112,
-    PGM = 113,
-    MPLS = 137,
-    PFSYNC = 240,
-};
-
-enum class SocketLevel : u32 {
-    IP = 0,
-    TCP = 6,
-    SOCKET = 0xffff, // i.e. SOL_SOCKET
-};
-
-enum class OptName : u32 {
-    REUSEADDR = 0x4,
-    KEEPALIVE = 0x8,
-    BROADCAST = 0x20,
-    LINGER = 0x80,
-    SNDBUF = 0x1001,
-    RCVBUF = 0x1002,
-    SNDTIMEO = 0x1005,
-    RCVTIMEO = 0x1006,
-    ERROR_ = 0x1007,   // avoid name collision with Windows macro
-    NOSIGPIPE = 0x800, // at least according to libnx
-    ACCEPTFILTER = 0x1000,
-    BINTIME = 0x2000,
-    NO_OFFLOAD = 0x4000,
-    NO_DDP = 0x8000,
-};
-
-enum class ShutdownHow : s32 {
-    RD = 0,
-    WR = 1,
-    RDWR = 2,
-};
-
-enum class FcntlCmd : s32 {
-    GETFL = 3,
-    SETFL = 4,
-};
-
-struct SockAddrIn {
-    u8 len;
-    u8 family;
-    u16 portno;
-    std::array<u8, 4> ip;
-    std::array<u8, 248> zeroes;
-};
-static_assert(sizeof(SockAddrIn) == 0x100);
-
-enum class PollEvents : u16 {
-    // Using Pascal case because IN is a macro on Windows.
-    In = 1 << 0,
-    Pri = 1 << 1,
-    Out = 1 << 2,
-    Err = 1 << 3,
-    Hup = 1 << 4,
-    Nval = 1 << 5,
-    RdNorm = 1 << 6,
-    RdBand = 1 << 7,
-    WrBand = 1 << 8,
-};
-
-DECLARE_ENUM_FLAG_OPERATORS(PollEvents);
-
-struct PollFD {
-    s32 fd;
-    PollEvents events;
-    PollEvents revents;
-};
-
-struct Linger {
-    u32 onoff;
-    u32 linger;
-};
-
 void LoopProcess(Core::System& system);
 
 } // namespace Service::Sockets

src/core/hle/service/sockets/sockets_translate.cpp

@@ -15,388 +15,42 @@
 
 namespace Service::Sockets {
 
-Errno Translate(Network::Errno value) {
-    switch (value) {
-    case Network::Errno::SUCCESS:
-        return Errno::SUCCESS;
-    case Network::Errno::BADF:
-        return Errno::BADF;
-    case Network::Errno::AGAIN:
-        return Errno::AGAIN;
-    case Network::Errno::INVAL:
-        return Errno::INVAL;
-    case Network::Errno::MFILE:
-        return Errno::MFILE;
-    case Network::Errno::PIPE:
-        return Errno::PIPE;
-    case Network::Errno::CONNREFUSED:
-        return Errno::CONNREFUSED;
-    case Network::Errno::NOTCONN:
-        return Errno::NOTCONN;
-    case Network::Errno::TIMEDOUT:
-        return Errno::TIMEDOUT;
-    case Network::Errno::CONNABORTED:
-        return Errno::CONNABORTED;
-    case Network::Errno::CONNRESET:
-        return Errno::CONNRESET;
-    case Network::Errno::INPROGRESS:
-        return Errno::INPROGRESS;
-    case Network::Errno::ISCONN:
-        return Errno::ISCONN;
-    default:
-        UNIMPLEMENTED_MSG("Unimplemented errno={}", value);
-        return Errno::SUCCESS;
-    }
-}
-
-std::pair<s32, Errno> Translate(std::pair<s32, Network::Errno> value) {
-    return {value.first, Translate(value.second)};
-}
-
-GetAddrInfoError Translate(Network::GetAddrInfoError error) {
-    switch (error) {
-    case Network::GetAddrInfoError::SUCCESS:
-        return GetAddrInfoError::SUCCESS;
-    case Network::GetAddrInfoError::ADDRFAMILY:
-        return GetAddrInfoError::ADDRFAMILY;
-    case Network::GetAddrInfoError::AGAIN:
-        return GetAddrInfoError::AGAIN;
-    case Network::GetAddrInfoError::BADFLAGS:
-        return GetAddrInfoError::BADFLAGS;
-    case Network::GetAddrInfoError::FAIL:
-        return GetAddrInfoError::FAIL;
-    case Network::GetAddrInfoError::FAMILY:
-        return GetAddrInfoError::FAMILY;
-    case Network::GetAddrInfoError::MEMORY:
-        return GetAddrInfoError::MEMORY;
-    case Network::GetAddrInfoError::NODATA:
-        return GetAddrInfoError::NODATA;
-    case Network::GetAddrInfoError::NONAME:
-        return GetAddrInfoError::NONAME;
-    case Network::GetAddrInfoError::SERVICE:
-        return GetAddrInfoError::SERVICE;
-    case Network::GetAddrInfoError::SOCKTYPE:
-        return GetAddrInfoError::SOCKTYPE;
-    case Network::GetAddrInfoError::SYSTEM:
-        return GetAddrInfoError::SYSTEM;
-    case Network::GetAddrInfoError::BADHINTS:
-        return GetAddrInfoError::BADHINTS;
-    case Network::GetAddrInfoError::PROTOCOL:
-        return GetAddrInfoError::PROTOCOL;
-    case Network::GetAddrInfoError::OVERFLOW_:
-        return GetAddrInfoError::OVERFLOW_;
-    case Network::GetAddrInfoError::OTHER:
-        return GetAddrInfoError::OTHER;
-    default:
-        UNIMPLEMENTED_MSG("Unimplemented GetAddrInfoError={}", error);
-        return GetAddrInfoError::OTHER;
-    }
-}
-
-const char* Translate(GetAddrInfoError error) {
+const char* Translate(Network::GetAddrInfoError error) {
     // https://android.googlesource.com/platform/bionic/+/085543106/libc/dns/net/getaddrinfo.c#254
     switch (error) {
-    case GetAddrInfoError::SUCCESS:
+    case Network::GetAddrInfoError::SUCCESS:
         return "Success";
-    case GetAddrInfoError::ADDRFAMILY:
+    case Network::GetAddrInfoError::ADDRFAMILY:
         return "Address family for hostname not supported";
-    case GetAddrInfoError::AGAIN:
+    case Network::GetAddrInfoError::AGAIN:
         return "Temporary failure in name resolution";
-    case GetAddrInfoError::BADFLAGS:
+    case Network::GetAddrInfoError::BADFLAGS:
         return "Invalid value for ai_flags";
-    case GetAddrInfoError::FAIL:
+    case Network::GetAddrInfoError::FAIL:
         return "Non-recoverable failure in name resolution";
-    case GetAddrInfoError::FAMILY:
+    case Network::GetAddrInfoError::FAMILY:
         return "ai_family not supported";
-    case GetAddrInfoError::MEMORY:
+    case Network::GetAddrInfoError::MEMORY:
         return "Memory allocation failure";
-    case GetAddrInfoError::NODATA:
+    case Network::GetAddrInfoError::NODATA:
         return "No address associated with hostname";
-    case GetAddrInfoError::NONAME:
+    case Network::GetAddrInfoError::NONAME:
         return "hostname nor servname provided, or not known";
-    case GetAddrInfoError::SERVICE:
+    case Network::GetAddrInfoError::SERVICE:
         return "servname not supported for ai_socktype";
-    case GetAddrInfoError::SOCKTYPE:
+    case Network::GetAddrInfoError::SOCKTYPE:
         return "ai_socktype not supported";
-    case GetAddrInfoError::SYSTEM:
+    case Network::GetAddrInfoError::SYSTEM:
         return "System error returned in errno";
-    case GetAddrInfoError::BADHINTS:
+    case Network::GetAddrInfoError::BADHINTS:
         return "Invalid value for hints";
-    case GetAddrInfoError::PROTOCOL:
+    case Network::GetAddrInfoError::PROTOCOL:
         return "Resolved protocol is unknown";
-    case GetAddrInfoError::OVERFLOW_:
+    case Network::GetAddrInfoError::OVERFLOW_:
         return "Argument buffer overflow";
     default:
         return "Unknown error";
     }
 }
 
-Network::Domain Translate(Domain domain) {
-    switch (domain) {
-    case Domain::Unspecified:
-        return Network::Domain::Unspecified;
-    case Domain::INET:
-        return Network::Domain::INET;
-    default:
-        UNIMPLEMENTED_MSG("Unimplemented domain={}", domain);
-        return {};
-    }
-}
-
-Domain Translate(Network::Domain domain) {
-    switch (domain) {
-    case Network::Domain::Unspecified:
-        return Domain::Unspecified;
-    case Network::Domain::INET:
-        return Domain::INET;
-    default:
-        UNIMPLEMENTED_MSG("Unimplemented domain={}", domain);
-        return {};
-    }
-}
-
-Network::Type Translate(Type type) {
-    switch (type) {
-    case Type::Unspecified:
-        return Network::Type::Unspecified;
-    case Type::STREAM:
-        return Network::Type::STREAM;
-    case Type::DGRAM:
-        return Network::Type::DGRAM;
-    case Type::RAW:
-        return Network::Type::RAW;
-    case Type::SEQPACKET:
-        return Network::Type::SEQPACKET;
-    default:
-        UNIMPLEMENTED_MSG("Unimplemented type={}", type);
-        return Network::Type{};
-    }
-}
-
-Type Translate(Network::Type type) {
-    switch (type) {
-    case Network::Type::Unspecified: return Type::Unspecified;
-    case Network::Type::STREAM: return Type::STREAM;
-    case Network::Type::DGRAM: return Type::DGRAM;
-    case Network::Type::RAW: return Type::RAW;
-    case Network::Type::SEQPACKET: return Type::SEQPACKET;
-    default:
-        UNIMPLEMENTED_MSG("Unimplemented type={}", type);
-        return Type{};
-    }
-}
-
-#define NETWORK_PROTOCOL_TRANSLATE_LIST \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(IP) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(ICMP) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(TCP) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(UDP) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(IPV6) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(RAW) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(IGMP) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(GGP) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(IPV4) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(ST) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(EGP) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(PIGP) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(RCCMON) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(NVPII) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(PUP) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(ARGUS) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(EMCON) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(XNET) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(CHAOS) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(MUX) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(MEAS) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(HMP) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(PRM) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(IDP) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(TRUNK1) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(TRUNK2) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(LEAF1) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(LEAF2) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(RDP) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(IRTP) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(TP) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(BLT) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(NSP) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(INP) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(DCCP) \
-    /*NETWORK_PROTOCOL_TRANSLATE_ELEM(3PC)*/ \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(IDPR) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(XTP) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(DDP) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(CMTP) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(TPXX) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(IL) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(SDRP) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(ROUTING) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(FRAGMENT) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(IDRP) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(RSVP) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(GRE) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(MHRP) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(BHA) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(ESP) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(AH) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(INLSP) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(SWIPE) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(NHRP) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(MOBILE) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(TLSP) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(SKIP) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(ICMPV6) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(NONE) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(DSTOPTS) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(AHIP) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(CFTP) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(HELLO) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(SATEXPAK) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(KRYPTOLAN) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(RVD) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(IPPC) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(ADFS) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(SATMON) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(VISA) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(IPCV) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(CPNX) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(CPHB) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(WSN) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(PVP) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(BRSATMON) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(ND) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(WBMON) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(WBEXPAK) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(EON) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(VMTP) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(SVMTP) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(VINES) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(TTP) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(IGP) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(DGP) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(TCF) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(IGRP) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(OSPFIGP) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(SRPC) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(LARP) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(MTP) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(AX25) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(IPEIP) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(MICP) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(SCCSP) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(ETHERIP) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(ENCAP) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(APES) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(GMTP) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(IPCOMP) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(SCTP) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(MH) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(UDPLITE) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(HIP) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(SHIM6) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(PIM) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(CARP) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(PGM) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(MPLS) \
-    NETWORK_PROTOCOL_TRANSLATE_ELEM(PFSYNC)
-[[nodiscard]] Network::Protocol Translate(Protocol protocol) {
-    switch (protocol) {
-#define NETWORK_PROTOCOL_TRANSLATE_ELEM(name) case Protocol::name: return Network::Protocol::name;
-    NETWORK_PROTOCOL_TRANSLATE_LIST
-#undef NETWORK_PROTOCOL_TRANSLATE_ELEM
-    default:
-        UNIMPLEMENTED_MSG("Unimplemented protocol={}", protocol);
-        return {};
-    }
-}
-[[nodiscard]] Protocol Translate(Network::Protocol protocol) {
-    switch (protocol) {
-#define NETWORK_PROTOCOL_TRANSLATE_ELEM(name) case Network::Protocol::name: return Protocol::name;
-    NETWORK_PROTOCOL_TRANSLATE_LIST
-#undef NETWORK_PROTOCOL_TRANSLATE_ELEM
-    default:
-        UNIMPLEMENTED_MSG("Unimplemented protocol={}", protocol);
-        return {};
-    }
-}
-#undef NETWORK_PROTOCOL_TRANSLATE_LIST
-
-Network::PollEvents Translate(PollEvents flags) {
-    Network::PollEvents result{};
-    const auto translate = [&result, &flags](PollEvents from, Network::PollEvents to) {
-        if (True(flags & from)) {
-            flags &= ~from;
-            result |= to;
-        }
-    };
-    translate(PollEvents::In, Network::PollEvents::In);
-    translate(PollEvents::Pri, Network::PollEvents::Pri);
-    translate(PollEvents::Out, Network::PollEvents::Out);
-    translate(PollEvents::Err, Network::PollEvents::Err);
-    translate(PollEvents::Hup, Network::PollEvents::Hup);
-    translate(PollEvents::Nval, Network::PollEvents::Nval);
-    translate(PollEvents::RdNorm, Network::PollEvents::RdNorm);
-    translate(PollEvents::RdBand, Network::PollEvents::RdBand);
-    translate(PollEvents::WrBand, Network::PollEvents::WrBand);
-
-    UNIMPLEMENTED_IF_MSG((u16)flags != 0, "Unimplemented flags={}", (u16)flags);
-    return result;
-}
-
-PollEvents Translate(Network::PollEvents flags) {
-    PollEvents result{};
-    const auto translate = [&result, &flags](Network::PollEvents from, PollEvents to) {
-        if (True(flags & from)) {
-            flags &= ~from;
-            result |= to;
-        }
-    };
-
-    translate(Network::PollEvents::In, PollEvents::In);
-    translate(Network::PollEvents::Pri, PollEvents::Pri);
-    translate(Network::PollEvents::Out, PollEvents::Out);
-    translate(Network::PollEvents::Err, PollEvents::Err);
-    translate(Network::PollEvents::Hup, PollEvents::Hup);
-    translate(Network::PollEvents::Nval, PollEvents::Nval);
-    translate(Network::PollEvents::RdNorm, PollEvents::RdNorm);
-    translate(Network::PollEvents::RdBand, PollEvents::RdBand);
-    translate(Network::PollEvents::WrBand, PollEvents::WrBand);
-
-    UNIMPLEMENTED_IF_MSG((u16)flags != 0, "Unimplemented flags={}", (u16)flags);
-    return result;
-}
-
-Network::SockAddrIn Translate(SockAddrIn value) {
-    // All lengths are valid, from [0 upto 256]
-    return {
-        .family = Translate(Domain(value.family)),
-        .ip = value.ip,
-        .portno = static_cast<u16>(value.portno >> 8 | value.portno << 8),
-    };
-}
-
-SockAddrIn Translate(Network::SockAddrIn value) {
-    return {
-        .len = 16,
-        .family = static_cast<u8>(Translate(value.family)),
-        .portno = static_cast<u16>(value.portno >> 8 | value.portno << 8),
-        .ip = value.ip,
-        .zeroes = {},
-    };
-}
-
-Network::ShutdownHow Translate(ShutdownHow how) {
-    switch (how) {
-    case ShutdownHow::RD:
-        return Network::ShutdownHow::RD;
-    case ShutdownHow::WR:
-        return Network::ShutdownHow::WR;
-    case ShutdownHow::RDWR:
-        return Network::ShutdownHow::RDWR;
-    default:
-        UNIMPLEMENTED_MSG("Unimplemented how={}", how);
-        return {};
-    }
-}
-
 } // namespace Service::Sockets

src/core/hle/service/sockets/sockets_translate.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -11,49 +14,7 @@
 
 namespace Service::Sockets {
 
-/// Translate abstract errno to guest errno
-Errno Translate(Network::Errno value);
-
-/// Translate abstract return value errno pair to guest return value errno pair
-std::pair<s32, Errno> Translate(std::pair<s32, Network::Errno> value);
-
-/// Translate abstract getaddrinfo error to guest getaddrinfo error
-GetAddrInfoError Translate(Network::GetAddrInfoError value);
-
 /// Translate guest error to string
-const char* Translate(GetAddrInfoError value);
-
-/// Translate guest domain to abstract domain
-Network::Domain Translate(Domain domain);
-
-/// Translate abstract domain to guest domain
-Domain Translate(Network::Domain domain);
-
-/// Translate guest type to abstract type
-Network::Type Translate(Type type);
-
-/// Translate abstract type to guest type
-Type Translate(Network::Type type);
-
-/// Translate guest protocol to abstract protocol
-Network::Protocol Translate(Protocol protocol);
-
-/// Translate abstract protocol to guest protocol
-Protocol Translate(Network::Protocol protocol);
-
-/// Translate guest poll event flags to abstract poll event flags
-Network::PollEvents Translate(PollEvents flags);
-
-/// Translate abstract poll event flags to guest poll event flags
-PollEvents Translate(Network::PollEvents flags);
-
-/// Translate guest socket address structure to abstract socket address structure
-Network::SockAddrIn Translate(SockAddrIn value);
-
-/// Translate abstract socket address structure to guest socket address structure
-SockAddrIn Translate(Network::SockAddrIn value);
-
-/// Translate guest shutdown mode to abstract shutdown mode
-Network::ShutdownHow Translate(ShutdownHow how);
+const char* Translate(Network::GetAddrInfoError value);
 
 } // namespace Service::Sockets

src/core/hle/service/ssl/ssl.cpp

@@ -132,7 +132,7 @@ public:
                 auto bsd = system.ServiceManager().GetService<Service::Sockets::BSD_USA>("bsd:u");
                 if (bsd) {
                     auto err = bsd->CloseImpl(fd);
-                    if (err != Service::Sockets::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;

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<const u8*>(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<u8*>(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:

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<size_t>(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<size_t>(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);

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<s32>(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:

src/core/internal_network/emu_net_state.h

@@ -1,10 +1,11 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 #pragma once
+
 #include <atomic>
-#include <common/socket_types.h>
 #include <mutex>
+#include "core/internal_network/socket_types.h"
 
 namespace Network {
 

src/core/internal_network/network.h

@@ -13,7 +13,7 @@
 
 #include "common/common_funcs.h"
 #include "common/common_types.h"
-#include "common/socket_types.h"
+#include "core/internal_network/socket_types.h"
 
 #ifdef _WIN32
 #include <winsock2.h>
@@ -31,68 +31,10 @@ namespace Network {
 class SocketBase;
 class Socket;
 
-/// Error code for network functions
-enum class Errno {
-    SUCCESS,
-    BADF,
-    INVAL,
-    MFILE,
-    PIPE,
-    NOTCONN,
-    AGAIN,
-    CONNREFUSED,
-    CONNRESET,
-    CONNABORTED,
-    HOSTUNREACH,
-    NETDOWN,
-    NETUNREACH,
-    TIMEDOUT,
-    MSGSIZE,
-    INPROGRESS,
-    ISCONN,
-    OTHER,
-};
-
-enum class GetAddrInfoError {
-    SUCCESS,
-    ADDRFAMILY,
-    AGAIN,
-    BADFLAGS,
-    FAIL,
-    FAMILY,
-    MEMORY,
-    NODATA,
-    NONAME,
-    SERVICE,
-    SOCKTYPE,
-    SYSTEM,
-    BADHINTS,
-    PROTOCOL,
-    OVERFLOW_,
-    OTHER,
-};
-
-/// Cross-platform poll fd structure
-
-enum class PollEvents : u16 {
-    // Using Pascal case because IN is a macro on Windows.
-    In = 1 << 0,
-    Pri = 1 << 1,
-    Out = 1 << 2,
-    Err = 1 << 3,
-    Hup = 1 << 4,
-    Nval = 1 << 5,
-    RdNorm = 1 << 6,
-    RdBand = 1 << 7,
-    WrBand = 1 << 8,
-};
-
-DECLARE_ENUM_FLAG_OPERATORS(PollEvents);
-
-struct PollFD {
-    SocketBase* socket;
-    PollEvents events;
-    PollEvents revents;
+struct HostPollFD {
+    SocketBase* socket = nullptr;
+    Network::PollEvents events = {};
+    Network::PollEvents revents = {};
 };
 
 class NetworkInstance {
@@ -101,6 +43,10 @@ public:
     ~NetworkInstance();
 };
 
+sockaddr_in TranslateFromSockAddrIn(Network::SockAddrIn input);
+Network::SockAddrIn TranslateToSockAddrIn(sockaddr_in input);
+s32 TranslateMsgOptToNative(s32 flags);
+
 void CancelPendingSocketOperations();
 void RestartSocketOperations();
 

src/core/internal_network/network_interface.cpp

@@ -46,7 +46,7 @@ namespace Network {
 
 #ifdef _WIN32
 
-std::vector<Network::NetworkInterface> GetAvailableNetworkInterfaces() {
+std::vector<NetworkInterface> GetAvailableNetworkInterfaces() {
 
     ULONG buf_size = 0;
     if (GetAdaptersAddresses(
@@ -66,7 +66,7 @@ std::vector<Network::NetworkInterface> GetAvailableNetworkInterfaces() {
         return {};
     }
 
-    std::vector<Network::NetworkInterface> result;
+    std::vector<NetworkInterface> result;
 
     for (auto* a = addrs; a; a = a->Next) {
 
@@ -89,7 +89,7 @@ std::vector<Network::NetworkInterface> GetAvailableNetworkInterfaces() {
             gw = reinterpret_cast<sockaddr_in*>(a->FirstGatewayAddress->Address.lpSockaddr)
                      ->sin_addr;
 
-        result.emplace_back(Network::NetworkInterface{
+        result.emplace_back(NetworkInterface{
             .name = Common::UTF16ToUTF8(std::wstring{a->FriendlyName}),
             .ip_address = ip,
             .subnet_mask = mask,
@@ -103,7 +103,7 @@ std::vector<Network::NetworkInterface> GetAvailableNetworkInterfaces() {
 
 #else
 
-std::vector<Network::NetworkInterface> GetAvailableNetworkInterfaces() {
+std::vector<NetworkInterface> GetAvailableNetworkInterfaces() {
 #if defined(__ANDROID__) || defined(__linux__)
     struct ifaddrs* ifaddr = nullptr;
     if (getifaddrs(&ifaddr) != 0) {
@@ -135,7 +135,7 @@ std::vector<Network::NetworkInterface> GetAvailableNetworkInterfaces() {
         LOG_WARNING(Network, "\"/proc/net/route\" not found - using gateway 0");
     }
 #endif
-    std::vector<Network::NetworkInterface> ifaces;
+    std::vector<NetworkInterface> ifaces;
     for (auto ifa = ifaddr; ifa != nullptr; ifa = ifa->ifa_next) {
         if (ifa->ifa_addr == nullptr || ifa->ifa_netmask == nullptr /* Have a netmask and address */
         || ifa->ifa_addr->sa_family != AF_INET /* Must be of kind AF_INET */
@@ -149,7 +149,7 @@ std::vector<Network::NetworkInterface> GetAvailableNetworkInterfaces() {
         });
         in_addr gw; // Solaris defines s_addr as a macro, can't use special C++ shenanigans here
         gw.s_addr = it != routes.end() ? it->gateway : 0;
-        ifaces.emplace_back(Network::NetworkInterface{
+        ifaces.emplace_back(NetworkInterface{
             .name = ifa->ifa_name,
             .ip_address = std::bit_cast<struct sockaddr_in>(*ifa->ifa_addr).sin_addr,
             .subnet_mask = std::bit_cast<struct sockaddr_in>(*ifa->ifa_netmask).sin_addr,
@@ -159,7 +159,7 @@ std::vector<Network::NetworkInterface> GetAvailableNetworkInterfaces() {
     freeifaddrs(ifaddr);
     return ifaces;
 #elif defined(__FreeBSD__)
-    std::vector<Network::NetworkInterface> ifaces;
+    std::vector<NetworkInterface> ifaces;
     int fd = ::socket(PF_ROUTE, SOCK_RAW, AF_UNSPEC);
     if (fd < 0) {
         LOG_ERROR(Network, "socket: {}", std::strerror(errno));
@@ -191,7 +191,7 @@ std::vector<Network::NetworkInterface> GetAvailableNetworkInterfaces() {
             size_t msglen = rtm->rtm_msglen - sizeof(*ifm);
             char const* p = (char const*)(ifm + 1);
 
-            Network::NetworkInterface iface{};
+            NetworkInterface iface{};
             for (size_t i = 0; i < RTAX_MAX; i++)
                 if ((ifm->ifm_addrs & (1 << i)) != 0) {
                     struct sockaddr const* sa = reinterpret_cast<struct sockaddr const*>(p);
@@ -220,7 +220,7 @@ std::vector<Network::NetworkInterface> GetAvailableNetworkInterfaces() {
 
 #endif // _WIN32
 
-std::optional<Network::NetworkInterface> GetSelectedNetworkInterface() {
+std::optional<NetworkInterface> GetSelectedNetworkInterface() {
     auto const& sel_if = Settings::values.network_interface.GetValue();
     if (auto const ifaces = Network::GetAvailableNetworkInterfaces(); ifaces.size() > 0) {
         if (sel_if.empty())

src/core/internal_network/socket_icmp.cpp

@@ -0,0 +1,277 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include <algorithm>
+#include <cerrno>
+#include <chrono>
+#include <mutex>
+#include <thread>
+#ifdef __unix__
+#include <spawn.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#endif
+#include "common/assert.h"
+#include "common/logging.h"
+#include "core/internal_network/socket_icmp.h"
+
+extern "C" {
+extern char **environ;
+}
+
+namespace Network {
+
+namespace {
+
+u16 ComputeChecksum(std::span<const u8> data) {
+    u32 sum = 0;
+    for (size_t i = 0; i < data.size(); i += 2) {
+        u32 value = (u32(data[i + 0]) << 8ull) | u32(data[i + 1]); //big endian
+        sum += value;
+    }
+    if (data.size() % 2 != 0){
+        sum += u16(data[data.size() - 1]) << 8;
+    }
+    while ((sum >> 16) != 0)
+        sum = (sum & 0xffff) + (sum >> 16);
+    return (~sum) & 0xffff;
+}
+
+}
+
+IcmpSocket::~IcmpSocket() {
+    if (fd == INVALID_SOCKET) {
+        return;
+    }
+    fd = INVALID_SOCKET;
+}
+
+Errno IcmpSocket::SetSockOpt(Network::SocketLevel level, Network::OptName optname, std::span<const u8> optval) {
+    LOG_WARNING(Network, "(stubbed) level={},optname={},optval={}", level, optname, optval.size());
+    if (optname == Network::OptName::RCVTIMEO) {
+        if (optval.size() < sizeof(Network::Timeval))
+            return Errno::E_INVAL;
+        std::memcpy(&rcv_timeo, optval.data(), sizeof(rcv_timeo));
+    }
+    return Errno::E_SUCCESS;
+}
+
+Errno IcmpSocket::Initialize(Domain domain, Type type, Protocol socket_protocol) {
+    return Errno::E_SUCCESS;
+}
+
+std::pair<IcmpSocket::AcceptResult, Errno> IcmpSocket::Accept() {
+    LOG_WARNING(Network, "(stubbed) called");
+    return {AcceptResult{}, Errno::E_SUCCESS};
+}
+
+Errno IcmpSocket::Connect(Network::SockAddrIn addr_in) {
+    LOG_WARNING(Network, "(stubbed) called");
+    connected_addr = addr_in;
+    return Errno::E_SUCCESS;
+}
+
+std::pair<Network::SockAddrIn, Errno> IcmpSocket::GetPeerName() {
+    LOG_WARNING(Network, "(stubbed) called");
+    return {Network::SockAddrIn{}, Errno::E_SUCCESS};
+}
+
+std::pair<Network::SockAddrIn, Errno> IcmpSocket::GetSockName() {
+    LOG_WARNING(Network, "(stubbed) called");
+    return {Network::SockAddrIn{}, Errno::E_SUCCESS};
+}
+
+Errno IcmpSocket::Bind(Network::SockAddrIn addr) {
+    LOG_WARNING(Network, "(stubbed) called");
+    return Errno::E_SUCCESS;
+}
+
+Errno IcmpSocket::Listen(s32 backlog) {
+    LOG_WARNING(Network, "(stubbed) called");
+    return Errno::E_SUCCESS;
+}
+
+Errno IcmpSocket::Shutdown(ShutdownHow how) {
+    LOG_WARNING(Network, "(stubbed) called");
+    return Errno::E_SUCCESS;
+}
+
+std::pair<s32, Errno> IcmpSocket::Recv(int flags, std::span<u8> message) {
+    LOG_DEBUG(Network, "(stubbed) called");
+    return connected_addr.has_value()
+        ? RecvFrom(flags, message, nullptr)
+        : std::make_pair(s32(0), Errno::E_NOTCONN);
+}
+
+std::pair<s32, Errno> IcmpSocket::RecvFrom(int flags, std::span<u8> message, Network::SockAddrIn* addr) {
+    LOG_DEBUG(Network, "(stubbed) called");
+    ASSERT(flags == 0);
+    ASSERT(message.size() < std::size_t((std::numeric_limits<int>::max)()));
+
+#if !defined(__OPENORBIS__) && (defined(__FreeBSD__) || defined(__linux__))
+    const auto rcv_timeout_ms = (s64(rcv_timeo.tv_sec) * 1000) + (s64(rcv_timeo.tv_usec) / 1000);
+    const auto timestamp = std::chrono::steady_clock::now();
+    while (true) {
+        {
+            std::lock_guard guard(pings_mutex);
+            // find ping process that is finished running
+            for (auto it = pings.begin(); it != pings.end();) {
+                pid_t result = waitpid(it->ping_pid, &it->ping_status, WNOHANG);
+                // ping process is still running, go to next
+                if (result != it->ping_pid) {
+                    ++it;
+                    continue;
+                }
+                // ping process is finished, remove and handle it
+                it = pings.erase(it);
+                if (it->ping_status == 0) {
+                    if (addr) {
+                        addr->family = it->family;
+                        addr->ip = it->ip;
+                        addr->portno = it->portno;
+                        addr->len = 16;
+                        addr->zeroes = {};
+                    }
+                    std::array<u8, 8> data{
+                        0,
+                        0,
+                        0, //checksum
+                        0,
+                        it->seq_ident[0],
+                        it->seq_ident[1],
+                        it->seq_ident[2],
+                        it->seq_ident[3]
+                    };
+                    auto const csum = ComputeChecksum(std::span<const u8>{data.begin(), data.end()});
+                    data[2] = u8(csum >> 8); //hi
+                    data[3] = u8(csum); //lo
+                    auto const n = std::min(data.size(), message.size());
+                    std::copy(data.begin(), data.begin() + n, message.begin());
+                    return {s32(n), Errno::E_SUCCESS};
+                }
+            }
+        }
+
+        if (!blocking)
+            return {-1, Errno::E_AGAIN};
+
+        const auto time_diff = std::chrono::steady_clock::now() - timestamp;
+        const auto time_diff_ms = std::chrono::duration_cast<std::chrono::milliseconds>(time_diff).count();
+        if (time_diff_ms > rcv_timeout_ms)
+            return {-1, Errno::E_TIMEDOUT};
+
+        std::this_thread::yield();
+    }
+#endif
+    return {-1, Errno::E_INVAL};
+}
+
+std::pair<s32, Errno> IcmpSocket::Send(std::span<const u8> message, int flags) {
+    LOG_DEBUG(Network, "(stubbed) called");
+    if (connected_addr.has_value())
+        return SendTo(flags, message, std::addressof(connected_addr.value()));
+    return {s32(0), Errno::E_NOTCONN};
+}
+
+std::pair<s32, Errno> IcmpSocket::SendTo(u32 flags, std::span<const u8> message, const Network::SockAddrIn* addr) {
+    LOG_DEBUG(Network, "(stubbed) called");
+    ASSERT(message.size() < size_t((std::numeric_limits<int>::max)()));
+    // 0 -> 8 (IPv4), 128 (IPv6)
+    // 1 -> 0
+    // 2..4 -> checksum
+    // 4..6 -> ident
+    // 6..8 -> seq
+
+    // 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
+#if !(defined(__OPENORBIS__) || defined(__ANDROID__)) && (defined(__FreeBSD__) || defined(__linux__))
+    const auto rcv_timeout_ms = (s64(rcv_timeo.tv_sec) * 1000) + (s64(rcv_timeo.tv_usec) / 1000);
+    if (!addr)
+        return {-1, Errno::E_DESTADDRREQ};
+
+    if (message.size() >= 8) {
+        std::string ip_str = fmt::format(
+            "{}.{}.{}.{}",
+            addr->ip[0],
+            addr->ip[1],
+            addr->ip[2],
+            addr->ip[3]
+        );
+#ifdef __FreeBSD__
+        // ping -W option is a nonfractional int (milliseconds)
+        std::string timeout_str = fmt::format("{}", rcv_timeout_ms);
+        std::vector<char*> argv = {
+            const_cast<char*>("ping"),
+            const_cast<char*>("-c"),
+            const_cast<char*>("1"),
+            const_cast<char*>("-W"),
+            timeout_str.data(),
+            ip_str.data(),
+            nullptr
+        };
+#elif defined(__linux__)
+        // ping -W option is a fractional float (seconds)
+        auto const rcv_timeout_s = f64(rcv_timeout_ms) / 1000.0;
+        std::string timeout_str = fmt::format("{}", rcv_timeout_s);
+        std::vector<char*> argv = {
+            const_cast<char*>("ping"),
+            const_cast<char*>("-c"),
+            const_cast<char*>("1"),
+            const_cast<char*>("-W"),
+            timeout_str.data(),
+            ip_str.data(),
+            nullptr
+        };
+#endif
+        pid_t ping_pid;
+        // we should pass in attributes to stop stdout spam, but im too lazy to figure that out
+        if (posix_spawnp(&ping_pid, "ping", nullptr, nullptr, argv.data(), environ) != 0) {
+            LOG_ERROR(Network, "Unable to start ping process for emulated ICMP socket");
+            return {-1, Errno::E_INVAL};
+        }
+        std::lock_guard guard(pings_mutex);
+        if (pings.size() >= pings.max_size())
+            pings.erase(pings.begin());
+        pings.push_back(PingProcessData{
+            .ip = addr->ip,
+            .portno = addr->portno,
+            .ping_pid = ping_pid,
+            .ping_status = 0,
+            .seq_ident = {
+                message[4],
+                message[5],
+                message[6],
+                message[7]
+            },
+            .family = addr->family,
+        });
+        return {s32(message.size()), Errno::E_SUCCESS};
+    }
+#endif
+    return {-1, Errno::E_INVAL};
+}
+
+Errno IcmpSocket::Close() {
+    LOG_DEBUG(Network, "called");
+    fd = INVALID_SOCKET;
+    return Errno::E_SUCCESS;
+}
+
+std::pair<Errno, Errno> IcmpSocket::GetPendingError() {
+    LOG_DEBUG(Network, "called");
+    return {Errno::E_SUCCESS, Errno::E_SUCCESS};
+}
+
+bool IcmpSocket::IsOpened() const {
+    return fd != INVALID_SOCKET;
+}
+
+void IcmpSocket::HandleProxyPacket(const ProxyPacket& packet) {
+    LOG_WARNING(Network, "(stubbed) called");
+}
+Errno IcmpSocket::SetNonBlock(bool enable) {
+    blocking = !enable;
+    return Errno::E_SUCCESS;
+}
+
+} // namespace Network

src/core/internal_network/socket_icmp.h

@@ -0,0 +1,56 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include <array>
+#include <span>
+#include <utility>
+#include <sys/types.h>
+#include <mutex>
+#include <boost/container/static_vector.hpp>
+#include "core/internal_network/socket_types.h"
+#include "core/internal_network/sockets.h"
+
+namespace Network {
+
+struct PingProcessData {
+    IPv4Address ip;
+    u16 portno;
+    pid_t ping_pid;
+    pid_t ping_status;
+    std::array<u8, 4> seq_ident;
+    u8 family;
+};
+
+class IcmpSocket : public Network::SocketBase {
+public:
+    explicit IcmpSocket() noexcept = default;
+    ~IcmpSocket() override;
+    Errno Initialize(Domain domain, Type type, Protocol socket_protocol) override;
+    Errno Close() override;
+    std::pair<AcceptResult, Errno> Accept() override;
+    Errno Connect(Network::SockAddrIn addr_in) override;
+    std::pair<Network::SockAddrIn, Errno> GetPeerName() override;
+    std::pair<Network::SockAddrIn, Errno> GetSockName() override;
+    Errno Bind(Network::SockAddrIn addr) override;
+    Errno Listen(s32 backlog) override;
+    Errno Shutdown(ShutdownHow how) override;
+    std::pair<s32, Errno> Recv(int flags, std::span<u8> message) override;
+    std::pair<s32, Errno> RecvFrom(int flags, std::span<u8> message, Network::SockAddrIn* addr) override;
+    std::pair<s32, Errno> Send(std::span<const u8> message, int flags) override;
+    std::pair<s32, Errno> SendTo(u32 flags, std::span<const u8> message, const Network::SockAddrIn* addr) override;
+    Errno SetSockOpt(Network::SocketLevel level, Network::OptName option, std::span<const u8> value) override;
+    std::pair<Errno, Errno> GetPendingError() override;
+    bool IsOpened() const override;
+    void HandleProxyPacket(const ProxyPacket& packet) override;
+    Errno SetNonBlock(bool enable) override;
+
+    boost::container::static_vector<PingProcessData, 128> pings;
+    std::optional<SockAddrIn> connected_addr;
+    std::mutex pings_mutex;
+    Network::Timeval rcv_timeo;
+    bool blocking = true;
+};
+
+} // namespace Network

src/core/internal_network/socket_proxy.cpp

@@ -47,71 +47,82 @@ void ProxySocket::HandleProxyPacket(const ProxyPacket& packet) {
     received_packets.push(decompressed);
 }
 
-template <typename T>
-Errno ProxySocket::SetSockOpt(SOCKET fd_, int option, T value) {
-    LOG_DEBUG(Network, "(STUBBED) called");
-    return Errno::SUCCESS;
+Errno ProxySocket::SetNonBlock(bool enable) {
+    blocking = !enable;
+    return Errno::E_SUCCESS;
+}
+
+Errno ProxySocket::SetSockOpt(Network::SocketLevel level, Network::OptName optname, std::span<const u8> optval) {
+    LOG_DEBUG(Network, "level={},optname={},optval={}", level, optname, optval.size());
+    // numeric values?
+    if (optval.size() >= sizeof(u32)) {
+        u32 value;
+        std::memcpy(&value, optval.data(), sizeof(value));
+        if (optname == Network::OptName::BROADCAST)
+            broadcast = bool(value);
+        if (optname == Network::OptName::SNDTIMEO)
+            send_timeout = value;
+        if (optname == Network::OptName::RCVTIMEO)
+            receive_timeout = value;
+    }
+    return Errno::E_SUCCESS;
 }
 
 Errno ProxySocket::Initialize(Domain domain, Type type, Protocol socket_protocol) {
     protocol = socket_protocol;
-    SetSockOpt(fd, SO_TYPE, type);
-
-    return Errno::SUCCESS;
+    return Errno::E_SUCCESS;
 }
 
 std::pair<ProxySocket::AcceptResult, Errno> ProxySocket::Accept() {
-    LOG_WARNING(Network, "(STUBBED) called");
-    return {AcceptResult{}, Errno::SUCCESS};
+    LOG_WARNING(Network, "(stubbed) called");
+    return {AcceptResult{}, Errno::E_SUCCESS};
 }
 
-Errno ProxySocket::Connect(SockAddrIn addr_in) {
-    LOG_WARNING(Network, "(STUBBED) called");
-    return Errno::SUCCESS;
+Errno ProxySocket::Connect(Network::SockAddrIn addr_in) {
+    LOG_WARNING(Network, "(stubbed) called");
+    return Errno::E_SUCCESS;
 }
 
-std::pair<SockAddrIn, Errno> ProxySocket::GetPeerName() {
-    LOG_WARNING(Network, "(STUBBED) called");
-    return {SockAddrIn{}, Errno::SUCCESS};
+std::pair<Network::SockAddrIn, Errno> ProxySocket::GetPeerName() {
+    LOG_WARNING(Network, "(stubbed) called");
+    return {Network::SockAddrIn{}, Errno::E_SUCCESS};
 }
 
-std::pair<SockAddrIn, Errno> ProxySocket::GetSockName() {
-    LOG_WARNING(Network, "(STUBBED) called");
-    return {SockAddrIn{}, Errno::SUCCESS};
+std::pair<Network::SockAddrIn, Errno> ProxySocket::GetSockName() {
+    LOG_WARNING(Network, "(stubbed) called");
+    return {Network::SockAddrIn{}, Errno::E_SUCCESS};
 }
 
-Errno ProxySocket::Bind(SockAddrIn addr) {
+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;
+    LOG_WARNING(Network, "(stubbed) called");
+    return Errno::E_SUCCESS;
 }
 
 Errno ProxySocket::Shutdown(ShutdownHow how) {
-    LOG_WARNING(Network, "(STUBBED) called");
-    return Errno::SUCCESS;
+    LOG_WARNING(Network, "(stubbed) called");
+    return Errno::E_SUCCESS;
 }
 
 std::pair<s32, Errno> ProxySocket::Recv(int flags, std::span<u8> message) {
-    LOG_WARNING(Network, "(STUBBED) called");
+    LOG_WARNING(Network, "(stubbed) called");
     ASSERT(flags == 0);
-    ASSERT(message.size() < static_cast<size_t>((std::numeric_limits<int>::max)()));
-
-    return {static_cast<s32>(0), Errno::SUCCESS};
+    ASSERT(message.size() < std::size_t((std::numeric_limits<int>::max)()));
+    return {s32(0), Errno::E_SUCCESS};
 }
 
-std::pair<s32, Errno> ProxySocket::RecvFrom(int flags, std::span<u8> message, SockAddrIn* addr) {
+std::pair<s32, Errno> ProxySocket::RecvFrom(int flags, std::span<u8> message, Network::SockAddrIn* addr) {
     ASSERT(flags == 0);
-    ASSERT(message.size() < static_cast<size_t>((std::numeric_limits<int>::max)()));
+    ASSERT(message.size() < std::size_t((std::numeric_limits<int>::max)()));
 
     // TODO (flTobi): Verify the timeout behavior and break when connection is lost
     const auto timestamp = std::chrono::steady_clock::now();
@@ -128,88 +139,85 @@ std::pair<s32, Errno> ProxySocket::RecvFrom(int flags, std::span<u8> message, So
         }
 
         if (!blocking) {
-            return {-1, Errno::AGAIN};
+            return {-1, Errno::E_AGAIN};
         }
 
         std::this_thread::yield();
 
         const auto time_diff = std::chrono::steady_clock::now() - timestamp;
-        const auto time_diff_ms =
-            std::chrono::duration_cast<std::chrono::milliseconds>(time_diff).count();
-
+        const auto time_diff_ms = std::chrono::duration_cast<std::chrono::milliseconds>(time_diff).count();
         if (time_diff_ms > timeout) {
-            return {-1, Errno::TIMEDOUT};
+            return {-1, Errno::E_TIMEDOUT};
         }
     }
 }
 
-std::pair<s32, Errno> ProxySocket::ReceivePacket(int flags, std::span<u8> message, SockAddrIn* addr,
-                                                 std::size_t max_length) {
+std::pair<s32, Errno> ProxySocket::ReceivePacket(int flags, std::span<u8> message, Network::SockAddrIn* addr, std::size_t max_length) {
+    LOG_DEBUG(Network, "called");
     ProxyPacket& packet = received_packets.front();
     if (addr) {
-        addr->family = Domain::INET;
+        addr->len = 16;
+        addr->family = u8(Network::Domain::INET);
         addr->ip = packet.local_endpoint.ip;         // The senders ip address
         addr->portno = packet.local_endpoint.portno; // The senders port number
+        addr->zeroes = {};
     }
 
-    bool peek = (flags & FLAG_MSG_PEEK) != 0;
+    bool peek = (flags & u32(Network::MsgOpt::PEEK)) != 0;
     std::size_t read_bytes;
     if (packet.data.size() > max_length) {
         read_bytes = max_length;
-        memcpy(message.data(), packet.data.data(), max_length);
+        std::memcpy(message.data(), packet.data.data(), max_length);
 
         if (protocol == Protocol::UDP) {
             if (!peek) {
                 received_packets.pop();
             }
-            return {-1, Errno::MSGSIZE};
+            return {-1, Errno::E_MSGSIZE};
         } else if (protocol == Protocol::TCP) {
             std::vector<u8> numArray(packet.data.size() - max_length);
-            std::copy(packet.data.begin() + max_length, packet.data.end(),
-                      std::back_inserter(numArray));
+            std::copy(packet.data.begin() + max_length, packet.data.end(), std::back_inserter(numArray));
             packet.data = numArray;
         }
     } else {
         read_bytes = packet.data.size();
-        memcpy(message.data(), packet.data.data(), read_bytes);
+        std::memcpy(message.data(), packet.data.data(), read_bytes);
         if (!peek) {
             received_packets.pop();
         }
     }
 
-    return {static_cast<u32>(read_bytes), Errno::SUCCESS};
+    return {u32(read_bytes), Errno::E_SUCCESS};
 }
 
 std::pair<s32, Errno> ProxySocket::Send(std::span<const u8> message, int flags) {
-    LOG_WARNING(Network, "(STUBBED) called");
-    ASSERT(message.size() < static_cast<size_t>((std::numeric_limits<int>::max)()));
+    LOG_WARNING(Network, "(stubbed) called");
+    ASSERT(message.size() < size_t((std::numeric_limits<int>::max)()));
     ASSERT(flags == 0);
-
-    return {static_cast<s32>(0), Errno::SUCCESS};
+    return {s32(0), Errno::E_SUCCESS};
 }
 
 void ProxySocket::SendPacket(ProxyPacket& packet) {
     if (auto room_member = Network::GetRoomMember().lock()) {
         if (room_member->IsConnected()) {
-            packet.data = Common::Compression::CompressDataZSTDDefault(packet.data.data(),
-                                                                       packet.data.size());
+            packet.data = Common::Compression::CompressDataZSTDDefault(packet.data.data(), packet.data.size());
             room_member->SendProxyPacket(packet);
         }
     }
 }
 
-std::pair<s32, Errno> ProxySocket::SendTo(u32 flags, std::span<const u8> message,
-                                          const SockAddrIn* addr) {
+std::pair<s32, Errno> ProxySocket::SendTo(u32 flags, std::span<const u8> message, const Network::SockAddrIn* addr) {
+    LOG_DEBUG(Network, "called");
     ASSERT(flags == 0);
 
     if (!is_bound) {
         LOG_ERROR(Network, "ProxySocket is not bound!");
-        return {static_cast<s32>(message.size()), Errno::SUCCESS};
+        return {s32(message.size()), Errno::E_SUCCESS};
     }
 
     if (auto room_member = Network::GetRoomMember().lock()) {
         if (!room_member->IsConnected()) {
-            return {static_cast<s32>(message.size()), Errno::SUCCESS};
+            return {s32(message.size()), Errno::E_SUCCESS};
         }
     }
 
@@ -234,66 +242,20 @@ std::pair<s32, Errno> ProxySocket::SendTo(u32 flags, std::span<const u8> message
 
     SendPacket(packet);
 
-    return {static_cast<s32>(message.size()), Errno::SUCCESS};
+    return {s32(message.size()), Errno::E_SUCCESS};
 }
 
 Errno ProxySocket::Close() {
+    LOG_DEBUG(Network, "called");
     fd = INVALID_SOCKET;
     closed = true;
 
-    return Errno::SUCCESS;
-}
-
-Errno ProxySocket::SetLinger(bool enable, u32 linger) {
-    struct Linger {
-        u16 linger_enable;
-        u16 linger_time;
-    } values;
-    values.linger_enable = enable ? 1 : 0;
-    values.linger_time = static_cast<u16>(linger);
-
-    return SetSockOpt(fd, SO_LINGER, values);
-}
-
-Errno ProxySocket::SetReuseAddr(bool enable) {
-    return SetSockOpt<u32>(fd, SO_REUSEADDR, enable ? 1 : 0);
-}
-
-Errno ProxySocket::SetBroadcast(bool enable) {
-    broadcast = enable;
-    return SetSockOpt<u32>(fd, SO_BROADCAST, enable ? 1 : 0);
-}
-
-Errno ProxySocket::SetSndBuf(u32 value) {
-    return SetSockOpt(fd, SO_SNDBUF, value);
-}
-
-Errno ProxySocket::SetKeepAlive(bool enable) {
-    return Errno::SUCCESS;
-}
-
-Errno ProxySocket::SetRcvBuf(u32 value) {
-    return SetSockOpt(fd, SO_RCVBUF, value);
-}
-
-Errno ProxySocket::SetSndTimeo(u32 value) {
-    send_timeout = value;
-    return SetSockOpt(fd, SO_SNDTIMEO, static_cast<int>(value));
-}
-
-Errno ProxySocket::SetRcvTimeo(u32 value) {
-    receive_timeout = value;
-    return SetSockOpt(fd, SO_RCVTIMEO, static_cast<int>(value));
-}
-
-Errno ProxySocket::SetNonBlock(bool enable) {
-    blocking = !enable;
-    return Errno::SUCCESS;
+    return Errno::E_SUCCESS;
 }
 
 std::pair<Errno, Errno> ProxySocket::GetPendingError() {
-    LOG_DEBUG(Network, "(STUBBED) called");
-    return {Errno::SUCCESS, Errno::SUCCESS};
+    LOG_DEBUG(Network, "called");
+    return {Errno::E_SUCCESS, Errno::E_SUCCESS};
 }
 
 bool ProxySocket::IsOpened() const {

src/core/internal_network/socket_proxy.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
@@ -29,13 +29,13 @@ public:
 
     std::pair<AcceptResult, Errno> Accept() override;
 
-    Errno Connect(SockAddrIn addr_in) override;
+    Errno Connect(Network::SockAddrIn addr_in) override;
 
-    std::pair<SockAddrIn, Errno> GetPeerName() override;
+    std::pair<Network::SockAddrIn, Errno> GetPeerName() override;
 
-    std::pair<SockAddrIn, Errno> GetSockName() override;
+    std::pair<Network::SockAddrIn, Errno> GetSockName() override;
 
-    Errno Bind(SockAddrIn addr) override;
+    Errno Bind(Network::SockAddrIn addr) override;
 
     Errno Listen(s32 backlog) override;
 
@@ -43,9 +43,9 @@ public:
 
     std::pair<s32, Errno> Recv(int flags, std::span<u8> message) override;
 
-    std::pair<s32, Errno> RecvFrom(int flags, std::span<u8> message, SockAddrIn* addr) override;
+    std::pair<s32, Errno> RecvFrom(int flags, std::span<u8> message, Network::SockAddrIn* addr) override;
 
-    std::pair<s32, Errno> ReceivePacket(int flags, std::span<u8> message, SockAddrIn* addr,
+    std::pair<s32, Errno> ReceivePacket(int flags, std::span<u8> message, Network::SockAddrIn* addr,
                                         std::size_t max_length);
 
     std::pair<s32, Errno> Send(std::span<const u8> message, int flags) override;
@@ -53,28 +53,11 @@ public:
     void SendPacket(ProxyPacket& packet);
 
     std::pair<s32, Errno> SendTo(u32 flags, std::span<const u8> message,
-                                 const SockAddrIn* addr) override;
-
-    Errno SetLinger(bool enable, u32 linger) override;
-
-    Errno SetReuseAddr(bool enable) override;
-
-    Errno SetBroadcast(bool enable) override;
-
-    Errno SetKeepAlive(bool enable) override;
-
-    Errno SetSndBuf(u32 value) override;
-
-    Errno SetRcvBuf(u32 value) override;
-
-    Errno SetSndTimeo(u32 value) override;
-
-    Errno SetRcvTimeo(u32 value) override;
+                                 const Network::SockAddrIn* addr) override;
 
     Errno SetNonBlock(bool enable) override;
 
-    template <typename T>
-    Errno SetSockOpt(SOCKET fd, int option, T value);
+    Errno SetSockOpt(Network::SocketLevel level, Network::OptName option, std::span<const u8> value) override;
 
     std::pair<Errno, Errno> GetPendingError() override;
 
@@ -86,7 +69,7 @@ private:
     u32 send_timeout = 0;
     u32 receive_timeout = 0;
     bool is_bound = false;
-    SockAddrIn local_endpoint{};
+    Network::SockAddrIn local_endpoint{};
     bool blocking = true;
     std::queue<ProxyPacket> received_packets;
     Protocol protocol;

src/core/internal_network/socket_types.h

@@ -0,0 +1,470 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <optional>
+#include <string>
+
+#include "common/common_types.h"
+#include "common/common_funcs.h"
+
+// Most of these structures are direct mappings of guest's
+// expectations for these values, in other words, they're the
+// values that HOS is expected to use AND handle.
+
+namespace Network {
+
+enum class Errno : u32 {
+    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 {
+    SUCCESS = 0,
+    ADDRFAMILY = 1,
+    AGAIN = 2,
+    BADFLAGS = 3,
+    FAIL = 4,
+    FAMILY = 5,
+    MEMORY = 6,
+    NODATA = 7,
+    NONAME = 8,
+    SERVICE = 9,
+    SOCKTYPE = 10,
+    SYSTEM = 11,
+    BADHINTS = 12,
+    PROTOCOL = 13,
+    OVERFLOW_ = 14, // avoid name collision with Windows macro
+    OTHER = 15,
+};
+
+enum class Domain : u32 {
+    Unspecified = 0,
+    UNIX = 1,
+    INET = 2,
+    IMPLINK = 3,
+    PUP = 4,
+    CHAOS = 5,
+    NETBIOS = 6,
+    ISO = 7,
+    ECMA = 8,
+    DATAKIT = 9,
+    CCITT = 10,
+    SNA = 11,
+    DECnet = 12,
+    DLI = 13,
+    LAT = 14,
+    HYLINK = 15,
+    APPLETALK = 16,
+    ROUTE = 17,
+    LINK = 18,
+    COIP = 20,
+    CNT = 21,
+    IPX = 23,
+    SIP = 24,
+    ISDN = 26,
+    INET6 = 28,
+    NATM = 29,
+    ATM = 30,
+    NETGRAPH = 32,
+    SLOW = 33,
+    SCLUSTER = 34,
+    ARP = 35,
+    BLUETOOTH = 36,
+    IEEE80211 = 37,
+    NETLINK = 38,
+    INET_SDP = 40,
+    INET6_SDP = 42,
+};
+
+enum class Type : u32 {
+    Unspecified = 0,
+    STREAM = 1,
+    DGRAM = 2,
+    RAW = 3,
+    RDM = 4,
+    SEQPACKET = 5,
+};
+
+enum class Protocol : u32 {
+    IP = 0,
+    ICMP = 1,
+    TCP = 6,
+    UDP = 17,
+    //
+    IPV6 = 41,
+    RAW = 255,
+    //
+    HOPOPTS = 0,
+    IGMP = 2,
+    GGP = 3,
+    IPV4 = 4,
+    ST = 7,
+    EGP = 8,
+    PIGP = 9,
+    RCCMON = 10,
+    NVPII = 11,
+    PUP = 12,
+    ARGUS = 13,
+    EMCON = 14,
+    XNET = 15,
+    CHAOS = 16,
+    MUX = 18,
+    MEAS = 19,
+    HMP = 20,
+    PRM = 21,
+    IDP = 22,
+    TRUNK1 = 23,
+    TRUNK2 = 24,
+    LEAF1 = 25,
+    LEAF2 = 26,
+    RDP = 27,
+    IRTP = 28,
+    TP = 29,
+    BLT = 30,
+    NSP = 31,
+    INP = 32,
+    DCCP = 33,
+    //3PC = 34,
+    IDPR = 35,
+    XTP = 36,
+    DDP = 37,
+    CMTP = 38,
+    TPXX = 39,
+    IL = 40,
+    SDRP = 42,
+    ROUTING = 43,
+    FRAGMENT = 44,
+    IDRP = 45,
+    RSVP = 46,
+    GRE = 47,
+    MHRP = 48,
+    BHA = 49,
+    ESP = 50,
+    AH = 51,
+    INLSP = 52,
+    SWIPE = 53,
+    NHRP = 54,
+    MOBILE = 55,
+    TLSP = 56,
+    SKIP = 57,
+    ICMPV6 = 58,
+    NONE = 59,
+    DSTOPTS = 60,
+    AHIP = 61,
+    CFTP = 62,
+    HELLO = 63,
+    SATEXPAK = 64,
+    KRYPTOLAN = 65,
+    RVD = 66,
+    IPPC = 67,
+    ADFS = 68,
+    SATMON = 69,
+    VISA = 70,
+    IPCV = 71,
+    CPNX = 72,
+    CPHB = 73,
+    WSN = 74,
+    PVP = 75,
+    BRSATMON = 76,
+    ND = 77,
+    WBMON = 78,
+    WBEXPAK = 79,
+    EON = 80,
+    VMTP = 81,
+    SVMTP = 82,
+    VINES = 83,
+    TTP = 84,
+    IGP = 85,
+    DGP = 86,
+    TCF = 87,
+    IGRP = 88,
+    OSPFIGP = 89,
+    SRPC = 90,
+    LARP = 91,
+    MTP = 92,
+    AX25 = 93,
+    IPEIP = 94,
+    MICP = 95,
+    SCCSP = 96,
+    ETHERIP = 97,
+    ENCAP = 98,
+    APES = 99,
+    GMTP = 100,
+    IPCOMP = 108,
+    SCTP = 132,
+    MH = 135,
+    UDPLITE = 136,
+    HIP = 139,
+    SHIM6 = 140,
+    PIM = 103,
+    CARP = 112,
+    PGM = 113,
+    MPLS = 137,
+    PFSYNC = 240,
+};
+
+enum class SocketLevel : u32 {
+    IP = 0,
+    ICMP = 1,
+    TCP = 6,
+    UDP = 17,
+    CONFIG = 0xfffe,
+    SOCKET = 0xffff, // i.e. SOL_SOCKET
+};
+
+enum class MsgOpt : u32 {
+    OOB = 0x00001,
+    PEEK = 0x00002,
+    DONTROUTE = 0x00004,
+    EOR_ = 0x00008,
+    TRUNC = 0x00010,
+    CTRUNC = 0x00020,
+    WAITALL = 0x00040,
+    DONTWAIT = 0x00080,
+    EOF_ = 0x00100,
+    NOSIGNAL = 0x20000,
+};
+
+enum class OptName : u32 {
+    DEBUG = 0x0001,
+    ACCEPTCONN = 0x0002,
+    REUSEADDR = 0x0004,
+    KEEPALIVE = 0x0008,
+    DONTROUTE = 0x0010,
+    BROADCAST = 0x0020,
+    USELOOPBACK = 0x0040,
+    LINGER = 0x0080,
+    OOBINLINE = 0x0100,
+    REUSEPORT = 0x0200,
+    TIMESTAMP = 0x0400,
+    NOSIGPIPE = 0x0800, // at least according to libnx
+    ACCEPTFILER = 0x1000,
+    SNDBUF = 0x1001,
+    RCVBUF = 0x1002,
+    SNDTIMEO = 0x1005,
+    RCVTIMEO = 0x1006,
+    ERROR_ = 0x1007,   // avoid name collision with Windows macro
+    ACCEPTFILTER = 0x1000,
+    BINTIME = 0x2000,
+    NO_OFFLOAD = 0x4000,
+    NO_DDP = 0x8000,
+};
+enum class TcpOptName : u32 {
+    NODELAY = 0x0001,
+    MAXSEG = 0x0002,
+    NOPUSH = 0x0004,
+    NOOPT = 0x0008,
+    MS5SIG = 0x0010,
+    INFO = 0x0020
+};
+
+enum class ShutdownHow : s32 {
+    RD = 0,
+    WR = 1,
+    RDWR = 2,
+};
+
+enum class FcntlCmd : s32 {
+    GETFL = 3,
+    SETFL = 4,
+};
+
+enum class FcntlFlags : u32 {
+    NONBLOCK = 0x004,
+    NONBLOCK_NX = 0x800,
+    // Provided for convenience
+    NONBLOCK_ANY = u32(NONBLOCK) | u32(NONBLOCK_NX),
+};
+
+/// Array of IPv4 address
+using IPv4Address = std::array<u8, 4>;
+
+struct SockAddrIn {
+    u8 len;
+    u8 family;
+    u16 portno;
+    IPv4Address ip;
+    std::array<u8, 248> zeroes;
+};
+static_assert(sizeof(SockAddrIn) == 0x100);
+
+enum class PollEvents : u16 {
+    // Using Pascal case because IN is a macro on Windows.
+    IN_ = 0x0001,
+    PRI_ = 0x0002,
+    OUT_ = 0x0004,
+    ERR_ = 0x0008,
+    HUP_ = 0x0010,
+    NVAL = 0x0020,
+    RDNORM = 0x0040,
+    RDBAND = 0x0080,
+    WRBAND = 0x0100,
+    IGNEOF = 0x2000,
+};
+DECLARE_ENUM_FLAG_OPERATORS(PollEvents);
+
+struct PollFD {
+    s32 fd;
+    Network::PollEvents events;
+    Network::PollEvents revents;
+};
+static_assert(sizeof(PollFD) == 8);
+
+struct Linger {
+    s32 onoff;
+    s32 linger;
+};
+static_assert(sizeof(Linger) == 8);
+
+struct Timeval {
+    u64 tv_sec;
+    u64 tv_usec;
+};
+static_assert(sizeof(Timeval) == 16);
+
+/// @brief Cross-platform addrinfo structure (not guest)
+struct AddrInfo {
+    Domain family;
+    Type socket_type;
+    Protocol protocol;
+    SockAddrIn addr;
+    std::optional<std::string> canon_name;
+};
+
+} // namespace Network

src/core/internal_network/sockets.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
@@ -30,7 +30,7 @@ public:
 
     struct AcceptResult {
         std::unique_ptr<SocketBase> socket;
-        SockAddrIn sockaddr_in;
+        Network::SockAddrIn sockaddr_in;
     };
 
     SocketBase() = default;
@@ -46,13 +46,13 @@ public:
 
     virtual std::pair<AcceptResult, Errno> Accept() = 0;
 
-    virtual Errno Connect(SockAddrIn addr_in) = 0;
+    virtual Errno Connect(Network::SockAddrIn addr_in) = 0;
 
-    virtual std::pair<SockAddrIn, Errno> GetPeerName() = 0;
+    virtual std::pair<Network::SockAddrIn, Errno> GetPeerName() = 0;
 
-    virtual std::pair<SockAddrIn, Errno> GetSockName() = 0;
+    virtual std::pair<Network::SockAddrIn, Errno> GetSockName() = 0;
 
-    virtual Errno Bind(SockAddrIn addr) = 0;
+    virtual Errno Bind(Network::SockAddrIn addr) = 0;
 
     virtual Errno Listen(s32 backlog) = 0;
 
@@ -60,31 +60,16 @@ public:
 
     virtual std::pair<s32, Errno> Recv(int flags, std::span<u8> message) = 0;
 
-    virtual std::pair<s32, Errno> RecvFrom(int flags, std::span<u8> message, SockAddrIn* addr) = 0;
+    virtual std::pair<s32, Errno> RecvFrom(int flags, std::span<u8> message, Network::SockAddrIn* addr) = 0;
 
     virtual std::pair<s32, Errno> Send(std::span<const u8> message, int flags) = 0;
 
-    virtual std::pair<s32, Errno> SendTo(u32 flags, std::span<const u8> message,
-                                         const SockAddrIn* addr) = 0;
-
-    virtual Errno SetLinger(bool enable, u32 linger) = 0;
-
-    virtual Errno SetReuseAddr(bool enable) = 0;
-
-    virtual Errno SetKeepAlive(bool enable) = 0;
-
-    virtual Errno SetBroadcast(bool enable) = 0;
-
-    virtual Errno SetSndBuf(u32 value) = 0;
-
-    virtual Errno SetRcvBuf(u32 value) = 0;
-
-    virtual Errno SetSndTimeo(u32 value) = 0;
-
-    virtual Errno SetRcvTimeo(u32 value) = 0;
+    virtual std::pair<s32, Errno> SendTo(u32 flags, std::span<const u8> message, const Network::SockAddrIn* addr) = 0;
 
     virtual Errno SetNonBlock(bool enable) = 0;
 
+    virtual Errno SetSockOpt(Network::SocketLevel level, Network::OptName option, std::span<const u8> value) = 0;
+
     virtual std::pair<Errno, Errno> GetPendingError() = 0;
 
     virtual bool IsOpened() const = 0;
@@ -95,7 +80,6 @@ public:
         return fd;
     }
 
-protected:
     SOCKET fd = INVALID_SOCKET;
 };
 
@@ -114,13 +98,13 @@ public:
 
     std::pair<AcceptResult, Errno> Accept() override;
 
-    Errno Connect(SockAddrIn addr_in) override;
+    Errno Connect(Network::SockAddrIn addr_in) override;
 
-    std::pair<SockAddrIn, Errno> GetPeerName() override;
+    std::pair<Network::SockAddrIn, Errno> GetPeerName() override;
 
-    std::pair<SockAddrIn, Errno> GetSockName() override;
+    std::pair<Network::SockAddrIn, Errno> GetSockName() override;
 
-    Errno Bind(SockAddrIn addr) override;
+    Errno Bind(Network::SockAddrIn addr) override;
 
     Errno Listen(s32 backlog) override;
 
@@ -128,38 +112,19 @@ public:
 
     std::pair<s32, Errno> Recv(int flags, std::span<u8> message) override;
 
-    std::pair<s32, Errno> RecvFrom(int flags, std::span<u8> message, SockAddrIn* addr) override;
+    std::pair<s32, Errno> RecvFrom(int flags, std::span<u8> message, Network::SockAddrIn* addr) override;
 
     std::pair<s32, Errno> Send(std::span<const u8> message, int flags) override;
 
-    std::pair<s32, Errno> SendTo(u32 flags, std::span<const u8> message,
-                                 const SockAddrIn* addr) override;
-
-    Errno SetLinger(bool enable, u32 linger) override;
-
-    Errno SetReuseAddr(bool enable) override;
-
-    Errno SetKeepAlive(bool enable) override;
-
-    Errno SetBroadcast(bool enable) override;
-
-    Errno SetSndBuf(u32 value) override;
-
-    Errno SetRcvBuf(u32 value) override;
-
-    Errno SetSndTimeo(u32 value) override;
-
-    Errno SetRcvTimeo(u32 value) override;
+    std::pair<s32, Errno> SendTo(u32 flags, std::span<const u8> message, const Network::SockAddrIn* addr) override;
 
     Errno SetNonBlock(bool enable) override;
 
-    template <typename T>
-    Errno SetSockOpt(SOCKET fd, int option, T value);
+    Errno SetSockOpt(Network::SocketLevel level, Network::OptName option, std::span<const u8> value) override;
 
     std::pair<Errno, Errno> GetPendingError() override;
 
-    template <typename T>
-    std::pair<T, Errno> GetSockOpt(SOCKET fd, int option);
+    Errno GetSockOpt(Network::SocketLevel level, Network::OptName optname, std::span<u8> value);
 
     bool IsOpened() const override;
 
@@ -169,6 +134,6 @@ private:
     bool is_non_blocking = false;
 };
 
-std::pair<s32, Errno> Poll(std::vector<PollFD>& poll_fds, s32 timeout);
+std::pair<s32, Errno> Poll(std::span<Network::HostPollFD> poll_fds, s32 timeout);
 
 } // namespace Network

src/network/room.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2017 Citra Emulator Project
@@ -12,7 +12,7 @@
 #include <vector>
 #include "common/announce_multiplayer_room.h"
 #include "common/common_types.h"
-#include "common/socket_types.h"
+#include "core/internal_network/socket_types.h"
 #include "network/verify_user.h"
 
 namespace Network {

src/network/room_member.cpp

@@ -10,7 +10,7 @@
 #include <thread>
 #include "common/assert.h"
 #include "common/polyfill_thread.h"
-#include "common/socket_types.h"
+#include "core/internal_network/socket_types.h"
 #include "enet/enet.h"
 #include "network/packet.h"
 #include "network/room_member.h"
@@ -358,19 +358,23 @@ void RoomMember::RoomMemberImpl::HandleProxyPackets(const ENetEvent* event) {
     // Parse the ProxyPacket from the packet
     u8 local_family;
     packet.Read(local_family);
-    proxy_packet.local_endpoint.family = static_cast<Domain>(local_family);
+    proxy_packet.local_endpoint.len = 16;
+    proxy_packet.local_endpoint.family = u8(Network::Domain(local_family));
     packet.Read(proxy_packet.local_endpoint.ip);
     packet.Read(proxy_packet.local_endpoint.portno);
+    proxy_packet.local_endpoint.zeroes = {};
 
     u8 remote_family;
     packet.Read(remote_family);
-    proxy_packet.remote_endpoint.family = static_cast<Domain>(remote_family);
+    proxy_packet.remote_endpoint.len = 16;
+    proxy_packet.remote_endpoint.family = u8(Network::Domain(remote_family));
     packet.Read(proxy_packet.remote_endpoint.ip);
     packet.Read(proxy_packet.remote_endpoint.portno);
+    proxy_packet.local_endpoint.zeroes = {};
 
     u8 protocol_type;
     packet.Read(protocol_type);
-    proxy_packet.protocol = static_cast<Protocol>(protocol_type);
+    proxy_packet.protocol = Network::Protocol(protocol_type);
 
     packet.Read(proxy_packet.broadcast);
     packet.Read(proxy_packet.data);

src/network/room_member.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2017 Citra Emulator Project
@@ -12,7 +12,7 @@
 #include <vector>
 #include "common/announce_multiplayer_room.h"
 #include "common/common_types.h"
-#include "common/socket_types.h"
+#include "core/internal_network/socket_types.h"
 #include "network/room.h"
 
 namespace Network {
@@ -39,8 +39,8 @@ struct LDNPacket {
 
 /// Information about the received proxy packets.
 struct ProxyPacket {
-    SockAddrIn local_endpoint;
-    SockAddrIn remote_endpoint;
+    Network::SockAddrIn local_endpoint;
+    Network::SockAddrIn remote_endpoint;
     Protocol protocol;
     bool broadcast;
     std::vector<u8> data;

src/shader_recompiler/backend/glsl/emit_glsl.cpp

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -32,7 +29,7 @@ struct FuncTraits<ReturnType_ (*)(Args...)> {
 };
 
 template <auto func, typename... Args>
-[[maybe_unused]] void SetDefinition(EmitContext& ctx, IR::Inst* inst, Args... args) {
+void SetDefinition(EmitContext& ctx, IR::Inst* inst, Args... args) {
     inst->SetDefinition<Id>(func(ctx, std::forward<Args>(args)...));
 }
 

src/shader_recompiler/backend/spirv/emit_spirv.cpp

@@ -492,9 +492,6 @@ void SetupCapabilities(const Profile& profile, const Info& info, EmitContext& ct
         if (ctx.uses_nonuniform_storage_texel_buffer) {
             ctx.AddCapability(spv::Capability::StorageTexelBufferArrayNonUniformIndexing);
         }
-        if (ctx.uses_nonuniform_storage_buffer) {
-            ctx.AddCapability(spv::Capability::StorageBufferArrayNonUniformIndexing);
-        }
     }
 }
 

src/shader_recompiler/backend/spirv/emit_spirv_atomic.cpp

@@ -4,6 +4,8 @@
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include <bit>
+
 #include "shader_recompiler/backend/spirv/emit_spirv.h"
 #include "shader_recompiler/backend/spirv/emit_spirv_instructions.h"
 #include "shader_recompiler/backend/spirv/spirv_emit_context.h"
@@ -21,13 +23,29 @@ Id SharedPointer(EmitContext& ctx, Id offset, u32 index_offset = 0) {
                : ctx.OpAccessChain(ctx.shared_u32, ctx.shared_memory_u32, index);
 }
 
+Id StorageIndex(EmitContext& ctx, const IR::Value& offset, size_t element_size) {
+    if (offset.IsImmediate()) {
+        const u32 imm_offset{static_cast<u32>(offset.U32() / element_size)};
+        return ctx.Const(imm_offset);
+    }
+    const u32 shift{static_cast<u32>(std::countr_zero(element_size))};
+    const Id index{ctx.Def(offset)};
+    if (shift == 0) {
+        return index;
+    }
+    const Id shift_id{ctx.Const(shift)};
+    return ctx.OpShiftRightLogical(ctx.U32[1], index, shift_id);
+}
+
 Id StoragePointer(EmitContext& ctx, const StorageTypeDefinition& type_def,
                   Id StorageDefinitions::*member_ptr, const IR::Value& binding,
                   const IR::Value& offset, size_t element_size) {
     if (!binding.IsImmediate()) {
         throw NotImplementedException("Dynamic storage buffer indexing");
     }
-    return ctx.StoragePointer(binding.U32(), ctx.Def(offset), type_def, static_cast<u32>(element_size), member_ptr);
+    const Id ssbo{ctx.ssbos[binding.U32()].*member_ptr};
+    const Id index{StorageIndex(ctx, offset, element_size)};
+    return ctx.OpAccessChain(type_def.element, ssbo, ctx.u32_zero_value, index);
 }
 
 std::pair<Id, Id> AtomicArgs(EmitContext& ctx) {
@@ -198,14 +216,16 @@ Id EmitStorageAtomicUMax32(EmitContext& ctx, const IR::Value& binding, const IR:
 
 Id EmitStorageAtomicInc32(EmitContext& ctx, const IR::Value& binding, const IR::Value& offset,
                           Id value) {
-    const Id pointer{StoragePointer(ctx, ctx.storage_types.U32, &StorageDefinitions::U32, binding, offset, sizeof(u32))};
-    return ctx.OpFunctionCall(ctx.U32[1], ctx.increment_cas_ssbo, pointer, value);
+    const Id ssbo{ctx.ssbos[binding.U32()].U32};
+    const Id base_index{StorageIndex(ctx, offset, sizeof(u32))};
+    return ctx.OpFunctionCall(ctx.U32[1], ctx.increment_cas_ssbo, base_index, value, ssbo);
 }
 
 Id EmitStorageAtomicDec32(EmitContext& ctx, const IR::Value& binding, const IR::Value& offset,
                           Id value) {
-    const Id pointer{StoragePointer(ctx, ctx.storage_types.U32, &StorageDefinitions::U32, binding, offset, sizeof(u32))};
-    return ctx.OpFunctionCall(ctx.U32[1], ctx.decrement_cas_ssbo, pointer, value);
+    const Id ssbo{ctx.ssbos[binding.U32()].U32};
+    const Id base_index{StorageIndex(ctx, offset, sizeof(u32))};
+    return ctx.OpFunctionCall(ctx.U32[1], ctx.decrement_cas_ssbo, base_index, value, ssbo);
 }
 
 Id EmitStorageAtomicAnd32(EmitContext& ctx, const IR::Value& binding, const IR::Value& offset,
@@ -344,49 +364,56 @@ Id EmitStorageAtomicExchange32x2(EmitContext& ctx, const IR::Value& binding,
 
 Id EmitStorageAtomicAddF32(EmitContext& ctx, const IR::Value& binding, const IR::Value& offset,
                            Id value) {
-    const Id pointer{StoragePointer(ctx, ctx.storage_types.U32, &StorageDefinitions::U32, binding, offset, sizeof(u32))};
-    return ctx.OpFunctionCall(ctx.F32[1], ctx.f32_add_cas, pointer, value);
+    const Id ssbo{ctx.ssbos[binding.U32()].U32};
+    const Id base_index{StorageIndex(ctx, offset, sizeof(u32))};
+    return ctx.OpFunctionCall(ctx.F32[1], ctx.f32_add_cas, base_index, value, ssbo);
 }
 
 Id EmitStorageAtomicAddF16x2(EmitContext& ctx, const IR::Value& binding, const IR::Value& offset,
                              Id value) {
-    const Id pointer{StoragePointer(ctx, ctx.storage_types.U32, &StorageDefinitions::U32, binding, offset, sizeof(u32))};
-    const Id result{ctx.OpFunctionCall(ctx.F16[2], ctx.f16x2_add_cas, pointer, value)};
+    const Id ssbo{ctx.ssbos[binding.U32()].U32};
+    const Id base_index{StorageIndex(ctx, offset, sizeof(u32))};
+    const Id result{ctx.OpFunctionCall(ctx.F16[2], ctx.f16x2_add_cas, base_index, value, ssbo)};
     return ctx.OpBitcast(ctx.U32[1], result);
 }
 
 Id EmitStorageAtomicAddF32x2(EmitContext& ctx, const IR::Value& binding, const IR::Value& offset,
                              Id value) {
-    const Id pointer{StoragePointer(ctx, ctx.storage_types.U32, &StorageDefinitions::U32, binding, offset, sizeof(u32))};
-    const Id result{ctx.OpFunctionCall(ctx.F32[2], ctx.f32x2_add_cas, pointer, value)};
+    const Id ssbo{ctx.ssbos[binding.U32()].U32};
+    const Id base_index{StorageIndex(ctx, offset, sizeof(u32))};
+    const Id result{ctx.OpFunctionCall(ctx.F32[2], ctx.f32x2_add_cas, base_index, value, ssbo)};
     return ctx.OpPackHalf2x16(ctx.U32[1], result);
 }
 
 Id EmitStorageAtomicMinF16x2(EmitContext& ctx, const IR::Value& binding, const IR::Value& offset,
                              Id value) {
-    const Id pointer{StoragePointer(ctx, ctx.storage_types.U32, &StorageDefinitions::U32, binding, offset, sizeof(u32))};
-    const Id result{ctx.OpFunctionCall(ctx.F16[2], ctx.f16x2_min_cas, pointer, value)};
+    const Id ssbo{ctx.ssbos[binding.U32()].U32};
+    const Id base_index{StorageIndex(ctx, offset, sizeof(u32))};
+    const Id result{ctx.OpFunctionCall(ctx.F16[2], ctx.f16x2_min_cas, base_index, value, ssbo)};
     return ctx.OpBitcast(ctx.U32[1], result);
 }
 
 Id EmitStorageAtomicMinF32x2(EmitContext& ctx, const IR::Value& binding, const IR::Value& offset,
                              Id value) {
-    const Id pointer{StoragePointer(ctx, ctx.storage_types.U32, &StorageDefinitions::U32, binding, offset, sizeof(u32))};
-    const Id result{ctx.OpFunctionCall(ctx.F32[2], ctx.f32x2_min_cas, pointer, value)};
+    const Id ssbo{ctx.ssbos[binding.U32()].U32};
+    const Id base_index{StorageIndex(ctx, offset, sizeof(u32))};
+    const Id result{ctx.OpFunctionCall(ctx.F32[2], ctx.f32x2_min_cas, base_index, value, ssbo)};
     return ctx.OpPackHalf2x16(ctx.U32[1], result);
 }
 
 Id EmitStorageAtomicMaxF16x2(EmitContext& ctx, const IR::Value& binding, const IR::Value& offset,
                              Id value) {
-    const Id pointer{StoragePointer(ctx, ctx.storage_types.U32, &StorageDefinitions::U32, binding, offset, sizeof(u32))};
-    const Id result{ctx.OpFunctionCall(ctx.F16[2], ctx.f16x2_max_cas, pointer, value)};
+    const Id ssbo{ctx.ssbos[binding.U32()].U32};
+    const Id base_index{StorageIndex(ctx, offset, sizeof(u32))};
+    const Id result{ctx.OpFunctionCall(ctx.F16[2], ctx.f16x2_max_cas, base_index, value, ssbo)};
     return ctx.OpBitcast(ctx.U32[1], result);
 }
 
 Id EmitStorageAtomicMaxF32x2(EmitContext& ctx, const IR::Value& binding, const IR::Value& offset,
                              Id value) {
-    const Id pointer{StoragePointer(ctx, ctx.storage_types.U32, &StorageDefinitions::U32, binding, offset, sizeof(u32))};
-    const Id result{ctx.OpFunctionCall(ctx.F32[2], ctx.f32x2_max_cas, pointer, value)};
+    const Id ssbo{ctx.ssbos[binding.U32()].U32};
+    const Id base_index{StorageIndex(ctx, offset, sizeof(u32))};
+    const Id result{ctx.OpFunctionCall(ctx.F32[2], ctx.f32x2_max_cas, base_index, value, ssbo)};
     return ctx.OpPackHalf2x16(ctx.U32[1], result);
 }
 

src/shader_recompiler/backend/spirv/emit_spirv_memory.cpp

@@ -4,33 +4,46 @@
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include <bit>
+
 #include "shader_recompiler/backend/spirv/emit_spirv.h"
 #include "shader_recompiler/backend/spirv/emit_spirv_instructions.h"
 #include "shader_recompiler/backend/spirv/spirv_emit_context.h"
 
 namespace Shader::Backend::SPIRV {
 namespace {
-Id StorageByteOffset(EmitContext& ctx, const IR::Value& offset, size_t element_size, u32 index_offset) {
-    Id byte_offset{ctx.Def(offset)};
-    if (index_offset != 0) {
-        byte_offset = ctx.OpIAdd(ctx.U32[1], byte_offset, ctx.Const(static_cast<u32>(index_offset * element_size)));
+Id StorageIndex(EmitContext& ctx, const IR::Value& offset, size_t element_size,
+                u32 index_offset = 0) {
+    if (offset.IsImmediate()) {
+        const u32 imm_offset{static_cast<u32>(offset.U32() / element_size) + index_offset};
+        return ctx.Const(imm_offset);
     }
-    return byte_offset;
+    const u32 shift{static_cast<u32>(std::countr_zero(element_size))};
+    Id index{ctx.Def(offset)};
+    if (shift != 0) {
+        const Id shift_id{ctx.Const(shift)};
+        index = ctx.OpShiftRightLogical(ctx.U32[1], index, shift_id);
+    }
+    if (index_offset != 0) {
+        index = ctx.OpIAdd(ctx.U32[1], index, ctx.Const(index_offset));
+    }
+    return index;
 }
 
 Id StoragePointer(EmitContext& ctx, const IR::Value& binding, const IR::Value& offset,
                   const StorageTypeDefinition& type_def, size_t element_size,
-                  Id StorageDefinitions::* member_ptr, u32 index_offset = 0) {
+                  Id StorageDefinitions::*member_ptr, u32 index_offset = 0) {
     if (!binding.IsImmediate()) {
         throw NotImplementedException("Dynamic storage buffer indexing");
     }
-    const Id byte_offset{StorageByteOffset(ctx, offset, element_size, index_offset)};
-    return ctx.StoragePointer(binding.U32(), byte_offset, type_def, static_cast<u32>(element_size), member_ptr);
+    const Id ssbo{ctx.ssbos[binding.U32()].*member_ptr};
+    const Id index{StorageIndex(ctx, offset, element_size, index_offset)};
+    return ctx.OpAccessChain(type_def.element, ssbo, ctx.u32_zero_value, index);
 }
 
 Id LoadStorage(EmitContext& ctx, const IR::Value& binding, const IR::Value& offset, Id result_type,
                const StorageTypeDefinition& type_def, size_t element_size,
-               Id StorageDefinitions::* member_ptr, u32 index_offset = 0) {
+               Id StorageDefinitions::*member_ptr, u32 index_offset = 0) {
     const Id pointer{
         StoragePointer(ctx, binding, offset, type_def, element_size, member_ptr, index_offset)};
     return ctx.OpLoad(result_type, pointer);
@@ -44,7 +57,7 @@ Id LoadStorage32(EmitContext& ctx, const IR::Value& binding, const IR::Value& of
 
 void WriteStorage(EmitContext& ctx, const IR::Value& binding, const IR::Value& offset, Id value,
                   const StorageTypeDefinition& type_def, size_t element_size,
-                  Id StorageDefinitions::* member_ptr, u32 index_offset = 0) {
+                  Id StorageDefinitions::*member_ptr, u32 index_offset = 0) {
     const Id pointer{
         StoragePointer(ctx, binding, offset, type_def, element_size, member_ptr, index_offset)};
     ctx.OpStore(pointer, value);

src/shader_recompiler/backend/spirv/spirv_emit_context.cpp

@@ -299,7 +299,7 @@ void DefineConstBuffers(EmitContext& ctx, const Info& info, Id UniformDefinition
 }
 
 void DefineSsbos(EmitContext& ctx, StorageTypeDefinition& type_def,
-                 Id StorageDefinitions::* member_type, const Info& info, u32 binding, Id type,
+                 Id StorageDefinitions::*member_type, const Info& info, u32 binding, Id type,
                  u32 stride) {
     const Id array_type{ctx.TypeRuntimeArray(type)};
     ctx.Decorate(array_type, spv::Decoration::ArrayStride, stride);
@@ -309,27 +309,23 @@ void DefineSsbos(EmitContext& ctx, StorageTypeDefinition& type_def,
     ctx.MemberDecorate(struct_type, 0, spv::Decoration::Offset, 0U);
 
     const Id struct_pointer{ctx.TypePointer(spv::StorageClass::StorageBuffer, struct_type)};
+    type_def.array = struct_pointer;
     type_def.element = ctx.TypePointer(spv::StorageClass::StorageBuffer, type);
 
     u32 index{};
     for (const StorageBufferDescriptor& desc : info.storage_buffers_descriptors) {
-        const Id variable_type{[&] {
-            if (desc.count == 1) {
-                return struct_pointer;
-            }
-            const Id descriptor_array{ctx.TypeArray(struct_type, ctx.Const(desc.count))};
-            return ctx.TypePointer(spv::StorageClass::StorageBuffer, descriptor_array);
-        }()};
-        const Id id{ctx.AddGlobalVariable(variable_type, spv::StorageClass::StorageBuffer)};
+        const Id id{ctx.AddGlobalVariable(struct_pointer, spv::StorageClass::StorageBuffer)};
         ctx.Decorate(id, spv::Decoration::Binding, binding);
         ctx.Decorate(id, spv::Decoration::DescriptorSet, 0U);
         ctx.Name(id, fmt::format("ssbo{}", index));
         if (ctx.profile.supported_spirv >= 0x00010400) {
             ctx.interfaces.push_back(id);
         }
-        ctx.ssbos[index].*member_type = id;
-        ++index;
-        ++binding;
+        for (size_t i = 0; i < desc.count; ++i) {
+            ctx.ssbos[index + i].*member_type = id;
+        }
+        index += desc.count;
+        binding += desc.count;
     }
 }
 
@@ -372,7 +368,8 @@ Id CasFunction(EmitContext& ctx, Operation operation, Id value_type) {
     return func;
 }
 
-Id CasLoop(EmitContext& ctx, Operation operation, Id element_pointer, Id value_type, Id memory_type, spv::Scope scope) {
+Id CasLoop(EmitContext& ctx, Operation operation, Id array_pointer, Id element_pointer,
+           Id value_type, Id memory_type, spv::Scope scope) {
     const bool is_shared{scope == spv::Scope::Workgroup};
     const bool is_struct{!is_shared || ctx.uses_explicit_workgroup_layout};
     const Id cas_func{CasFunction(ctx, operation, value_type)};
@@ -382,12 +379,14 @@ Id CasLoop(EmitContext& ctx, Operation operation, Id element_pointer, Id value_t
     const Id loop_header{ctx.OpLabel()};
     const Id continue_block{ctx.OpLabel()};
     const Id merge_block{ctx.OpLabel()};
-    const Id func_type{is_shared ? ctx.TypeFunction(value_type, ctx.U32[1], value_type)
-                                 : ctx.TypeFunction(value_type, element_pointer, value_type)};
+    const Id func_type{is_shared
+                           ? ctx.TypeFunction(value_type, ctx.U32[1], value_type)
+                           : ctx.TypeFunction(value_type, ctx.U32[1], value_type, array_pointer)};
 
     const Id func{ctx.OpFunction(value_type, spv::FunctionControlMask::MaskNone, func_type)};
-    const Id address{ctx.OpFunctionParameter(is_shared ? ctx.U32[1] : element_pointer)};
+    const Id index{ctx.OpFunctionParameter(ctx.U32[1])};
     const Id op_b{ctx.OpFunctionParameter(value_type)};
+    const Id base{is_shared ? ctx.shared_memory_u32 : ctx.OpFunctionParameter(array_pointer)};
     ctx.AddLabel();
     ctx.OpBranch(loop_header);
     ctx.AddLabel(loop_header);
@@ -396,13 +395,8 @@ Id CasLoop(EmitContext& ctx, Operation operation, Id element_pointer, Id value_t
     ctx.OpBranch(continue_block);
 
     ctx.AddLabel(continue_block);
-    const Id word_pointer{[&] {
-        if (!is_shared) {
-            return address;
-        }
-        return is_struct ? ctx.OpAccessChain(element_pointer, ctx.shared_memory_u32, zero, address)
-                         : ctx.OpAccessChain(element_pointer, ctx.shared_memory_u32, address);
-    }()};
+    const Id word_pointer{is_struct ? ctx.OpAccessChain(element_pointer, base, zero, index)
+                                    : ctx.OpAccessChain(element_pointer, base, index)};
     if (value_type.value == ctx.F32[2].value) {
         const Id u32_value{ctx.OpLoad(ctx.U32[1], word_pointer)};
         const Id value{ctx.OpUnpackHalf2x16(ctx.F32[2], u32_value)};
@@ -486,7 +480,6 @@ EmitContext::EmitContext(const Profile& profile_, const RuntimeInfo& runtime_inf
     DefineSharedMemoryFunctions(program);
     DefineConstantBuffers(program.info, uniform_binding);
     DefineConstantBufferIndirectFunctions(program.info);
-    DefineStorageBufferMappings(program.info, storage_binding);
     DefineStorageBuffers(program.info, storage_binding);
     DefineTextureBuffers(program.info, texture_binding);
     DefineImageBuffers(program.info, image_binding);
@@ -539,36 +532,6 @@ Id EmitContext::BitOffset16(const IR::Value& offset) {
     return OpBitwiseAnd(U32[1], OpShiftLeftLogical(U32[1], Def(offset), Const(3u)), Const(16u));
 }
 
-Id EmitContext::StoragePointer(u32 binding, Id byte_offset, const StorageTypeDefinition& type_def,
-                               u32 element_size, Id StorageDefinitions::* member_ptr) {
-    const Id ssbo{ssbos[binding].*member_ptr};
-    const u32 segment_count{storage_buffer_mapping_counts[binding]};
-    if (segment_count <= 1) {
-        const Id index{
-            element_size == 1
-                ? byte_offset
-                : OpShiftRightLogical(U32[1], byte_offset, Const(static_cast<u32>(std::countr_zero(element_size))))};
-        return OpAccessChain(type_def.element, ssbo, u32_zero_value, index);
-    }
-
-    const Id mapped{OpFunctionCall(U32[2], storage_buffer_map_func,
-                                   Const(storage_buffer_mapping_bases[binding]),
-                                   Const(segment_count), byte_offset)};
-    const Id segment{OpCompositeExtract(U32[1], mapped, 0U)};
-    const Id local_offset{OpCompositeExtract(U32[1], mapped, 1U)};
-    const Id index{
-        element_size == 1
-            ? local_offset
-            : OpShiftRightLogical(U32[1], local_offset, Const(static_cast<u32>(std::countr_zero(element_size))))};
-    Decorate(segment, spv::Decoration::NonUniform);
-    non_uniform_ids.insert(segment.value);
-    const Id pointer{OpAccessChain(type_def.element, ssbo, segment, u32_zero_value, index)};
-    Decorate(pointer, spv::Decoration::NonUniform);
-    non_uniform_ids.insert(pointer.value);
-    uses_nonuniform_storage_buffer = true;
-    return pointer;
-}
-
 void EmitContext::DefineCommonTypes(const Info& info) {
     void_id = TypeVoid();
 
@@ -733,10 +696,12 @@ void EmitContext::DefineSharedMemory(const IR::Program& program) {
 
 void EmitContext::DefineSharedMemoryFunctions(const IR::Program& program) {
     if (program.info.uses_shared_increment) {
-        increment_cas_shared = CasLoop(*this, Operation::Increment, shared_u32, U32[1], U32[1], spv::Scope::Workgroup);
+        increment_cas_shared = CasLoop(*this, Operation::Increment, shared_memory_u32_type,
+                                       shared_u32, U32[1], U32[1], spv::Scope::Workgroup);
     }
     if (program.info.uses_shared_decrement) {
-        decrement_cas_shared = CasLoop(*this, Operation::Decrement, shared_u32, U32[1], U32[1], spv::Scope::Workgroup);
+        decrement_cas_shared = CasLoop(*this, Operation::Decrement, shared_memory_u32_type,
+                                       shared_u32, U32[1], U32[1], spv::Scope::Workgroup);
     }
 }
 
@@ -980,7 +945,8 @@ void EmitContext::DefineGlobalMemoryFunctions(const Info& info) {
     }
     using DefPtr = Id StorageDefinitions::*;
     const Id zero{u32_zero_value};
-    const auto define_body{[&](DefPtr ssbo_member, Id addr, const StorageTypeDefinition& type_def, u32 shift, auto&& callback) {
+    const auto define_body{[&](DefPtr ssbo_member, Id addr, Id element_pointer, u32 shift,
+                               auto&& callback) {
         AddLabel();
         const size_t num_buffers{info.storage_buffers_descriptors.size()};
         for (size_t index = 0; index < num_buffers; ++index) {
@@ -1007,28 +973,30 @@ void EmitContext::DefineGlobalMemoryFunctions(const Info& info) {
             OpSelectionMerge(else_label, spv::SelectionControlMask::MaskNone);
             OpBranchConditional(cond, then_label, else_label);
             AddLabel(then_label);
+            const Id ssbo_id{ssbos[index].*ssbo_member};
             const Id ssbo_offset{OpUConvert(U32[1], OpISub(U64, addr, ssbo_addr))};
-            const Id ssbo_pointer{StoragePointer(static_cast<u32>(index), ssbo_offset, type_def, 1U << shift, ssbo_member)};
+            const Id ssbo_index{OpShiftRightLogical(U32[1], ssbo_offset, Const(shift))};
+            const Id ssbo_pointer{OpAccessChain(element_pointer, ssbo_id, zero, ssbo_index)};
             callback(ssbo_pointer);
             AddLabel(else_label);
         }
     }};
-    const auto define_load{
-        [&](DefPtr ssbo_member, const StorageTypeDefinition& type_def, Id type, u32 shift) {
-            const Id function_type{TypeFunction(type, U64)};
-            const Id func_id{OpFunction(type, spv::FunctionControlMask::MaskNone, function_type)};
-            const Id addr{OpFunctionParameter(U64)};
-            define_body(ssbo_member, addr, type_def, shift, [&](Id ssbo_pointer) { OpReturnValue(OpLoad(type, ssbo_pointer)); });
-            OpReturnValue(ConstantNull(type));
-            OpFunctionEnd();
-            return func_id;
-        }};
-    const auto define_write{[&](DefPtr ssbo_member, const StorageTypeDefinition& type_def, Id type, u32 shift) {
+    const auto define_load{[&](DefPtr ssbo_member, Id element_pointer, Id type, u32 shift) {
+        const Id function_type{TypeFunction(type, U64)};
+        const Id func_id{OpFunction(type, spv::FunctionControlMask::MaskNone, function_type)};
+        const Id addr{OpFunctionParameter(U64)};
+        define_body(ssbo_member, addr, element_pointer, shift,
+                    [&](Id ssbo_pointer) { OpReturnValue(OpLoad(type, ssbo_pointer)); });
+        OpReturnValue(ConstantNull(type));
+        OpFunctionEnd();
+        return func_id;
+    }};
+    const auto define_write{[&](DefPtr ssbo_member, Id element_pointer, Id type, u32 shift) {
         const Id function_type{TypeFunction(void_id, U64, type)};
         const Id func_id{OpFunction(void_id, spv::FunctionControlMask::MaskNone, function_type)};
         const Id addr{OpFunctionParameter(U64)};
         const Id data{OpFunctionParameter(type)};
-        define_body(ssbo_member, addr, type_def, shift, [&](Id ssbo_pointer) {
+        define_body(ssbo_member, addr, element_pointer, shift, [&](Id ssbo_pointer) {
             OpStore(ssbo_pointer, data);
             OpReturn();
         });
@@ -1038,9 +1006,10 @@ void EmitContext::DefineGlobalMemoryFunctions(const Info& info) {
     }};
     const auto define{
         [&](DefPtr ssbo_member, const StorageTypeDefinition& type_def, Id type, size_t size) {
+            const Id element_type{type_def.element};
             const u32 shift{static_cast<u32>(std::countr_zero(size))};
-            const Id load_func{define_load(ssbo_member, type_def, type, shift)};
-            const Id write_func{define_write(ssbo_member, type_def, type, shift)};
+            const Id load_func{define_load(ssbo_member, element_type, type, shift)};
+            const Id write_func{define_write(ssbo_member, element_type, type, shift)};
             return std::make_pair(load_func, write_func);
         }};
     std::tie(load_global_func_u32, write_global_func_u32) =
@@ -1259,79 +1228,6 @@ void EmitContext::DefineConstantBufferIndirectFunctions(const Info& info) {
     }
 }
 
-void EmitContext::DefineStorageBufferMappings(const Info& info, u32& binding) {
-    if (!UsesStorageBufferMappings(info)) {
-        return;
-    }
-    ASSERT(profile.support_storage_buffer_array_nonuniform_indexing);
-    AddExtension("SPV_KHR_storage_buffer_storage_class");
-
-    const u32 num_entries{NumDescriptors(info.storage_buffers_descriptors)};
-    const Id array_type{TypeArray(U32[1], Const(num_entries))};
-    Decorate(array_type, spv::Decoration::ArrayStride, sizeof(u32));
-    const Id struct_type{TypeStruct(array_type)};
-    Decorate(struct_type, spv::Decoration::Block);
-    MemberName(struct_type, 0, "segment_sizes");
-    MemberDecorate(struct_type, 0, spv::Decoration::Offset, 0U);
-    const Id pointer_type{TypePointer(spv::StorageClass::StorageBuffer, struct_type)};
-    storage_buffer_mapping_u32 = TypePointer(spv::StorageClass::StorageBuffer, U32[1]);
-    storage_buffer_mapping = AddGlobalVariable(pointer_type, spv::StorageClass::StorageBuffer);
-    Decorate(storage_buffer_mapping, spv::Decoration::Binding, binding++);
-    Decorate(storage_buffer_mapping, spv::Decoration::DescriptorSet, 0U);
-    Name(storage_buffer_mapping, "storage_buffer_mapping");
-    //Starting with version 1.4... (https://registry.khronos.org/SPIR-V/specs/unified1/SPIRV.html)
-    if (profile.supported_spirv >= 0x00010400) {
-        interfaces.push_back(storage_buffer_mapping);
-    }
-
-    u32 mapping_base{};
-    for (u32 index = 0; index < info.storage_buffers_descriptors.size(); ++index) {
-        const StorageBufferDescriptor& desc = info.storage_buffers_descriptors[index];
-        storage_buffer_mapping_bases[index] = mapping_base;
-        storage_buffer_mapping_counts[index] = desc.count;
-        mapping_base += desc.count;
-    }
-
-    const Id function_type{TypeFunction(U32[2], U32[1], U32[1], U32[1])};
-    storage_buffer_map_func = OpFunction(U32[2], spv::FunctionControlMask::MaskNone, function_type);
-    const Id base{OpFunctionParameter(U32[1])};
-    const Id count{OpFunctionParameter(U32[1])};
-    const Id byte_offset{OpFunctionParameter(U32[1])};
-    const Id index_pointer_type{TypePointer(spv::StorageClass::Function, U32[1])};
-    const Id loop_header{OpLabel()};
-    const Id continue_block{OpLabel()};
-    const Id merge_block{OpLabel()};
-    AddLabel();
-    const Id segment_var{AddLocalVariable(index_pointer_type, spv::StorageClass::Function)};
-    const Id offset_var{AddLocalVariable(index_pointer_type, spv::StorageClass::Function)};
-    OpStore(segment_var, u32_zero_value);
-    OpStore(offset_var, byte_offset);
-    OpBranch(loop_header);
-
-    AddLabel(loop_header);
-    const Id segment{OpLoad(U32[1], segment_var)};
-    const Id local_offset{OpLoad(U32[1], offset_var)};
-    const Id mapping_index{OpIAdd(U32[1], base, segment)};
-    const Id size_pointer{OpAccessChain(storage_buffer_mapping_u32, storage_buffer_mapping, u32_zero_value, mapping_index)};
-    const Id segment_size{OpLoad(U32[1], size_pointer)};
-    const Id fits{OpULessThan(U1, local_offset, segment_size)};
-    const Id last_segment{OpISub(U32[1], count, Const(1U))};
-    const Id is_last{OpIEqual(U1, segment, last_segment)};
-    const Id found{OpLogicalOr(U1, fits, is_last)};
-    OpLoopMerge(merge_block, continue_block, spv::LoopControlMask::MaskNone);
-    OpBranchConditional(found, merge_block, continue_block);
-
-    AddLabel(continue_block);
-    OpStore(offset_var, OpISub(U32[1], local_offset, segment_size));
-    OpStore(segment_var, OpIAdd(U32[1], segment, Const(1U)));
-    OpBranch(loop_header);
-
-    AddLabel(merge_block);
-    OpReturnValue(OpCompositeConstruct(U32[2], segment, local_offset));
-    OpFunctionEnd();
-    Name(storage_buffer_map_func, "map_storage_buffer");
-}
-
 void EmitContext::DefineStorageBuffers(const Info& info, u32& binding) {
     if (info.storage_buffers_descriptors.empty()) {
         return;
@@ -1375,7 +1271,9 @@ void EmitContext::DefineStorageBuffers(const Info& info, u32& binding) {
         DefineSsbos(*this, storage_types.U32x4, &StorageDefinitions::U32x4, info, binding, U32[4],
                     sizeof(u32[4]));
     }
-    binding += static_cast<u32>(info.storage_buffers_descriptors.size());
+    for (const StorageBufferDescriptor& desc : info.storage_buffers_descriptors) {
+        binding += desc.count;
+    }
     const bool needs_function{
         info.uses_global_increment || info.uses_global_decrement || info.uses_atomic_f32_add ||
         info.uses_atomic_f16x2_add || info.uses_atomic_f16x2_min || info.uses_atomic_f16x2_max ||
@@ -1384,31 +1282,40 @@ void EmitContext::DefineStorageBuffers(const Info& info, u32& binding) {
         AddCapability(spv::Capability::VariablePointersStorageBuffer);
     }
     if (info.uses_global_increment) {
-        increment_cas_ssbo = CasLoop(*this, Operation::Increment, storage_types.U32.element, U32[1], U32[1], spv::Scope::Device);
+        increment_cas_ssbo = CasLoop(*this, Operation::Increment, storage_types.U32.array,
+                                     storage_types.U32.element, U32[1], U32[1], spv::Scope::Device);
     }
     if (info.uses_global_decrement) {
-        decrement_cas_ssbo = CasLoop(*this, Operation::Decrement, storage_types.U32.element, U32[1], U32[1], spv::Scope::Device);
+        decrement_cas_ssbo = CasLoop(*this, Operation::Decrement, storage_types.U32.array,
+                                     storage_types.U32.element, U32[1], U32[1], spv::Scope::Device);
     }
     if (info.uses_atomic_f32_add) {
-        f32_add_cas = CasLoop(*this, Operation::FPAdd, storage_types.U32.element, F32[1], U32[1], spv::Scope::Device);
+        f32_add_cas = CasLoop(*this, Operation::FPAdd, storage_types.U32.array,
+                              storage_types.U32.element, F32[1], U32[1], spv::Scope::Device);
     }
     if (info.uses_atomic_f16x2_add) {
-        f16x2_add_cas = CasLoop(*this, Operation::FPAdd, storage_types.U32.element, F16[2], F16[2], spv::Scope::Device);
+        f16x2_add_cas = CasLoop(*this, Operation::FPAdd, storage_types.U32.array,
+                                storage_types.U32.element, F16[2], F16[2], spv::Scope::Device);
     }
     if (info.uses_atomic_f16x2_min) {
-        f16x2_min_cas = CasLoop(*this, Operation::FPMin, storage_types.U32.element, F16[2], F16[2], spv::Scope::Device);
+        f16x2_min_cas = CasLoop(*this, Operation::FPMin, storage_types.U32.array,
+                                storage_types.U32.element, F16[2], F16[2], spv::Scope::Device);
     }
     if (info.uses_atomic_f16x2_max) {
-        f16x2_max_cas = CasLoop(*this, Operation::FPMax, storage_types.U32.element, F16[2], F16[2], spv::Scope::Device);
+        f16x2_max_cas = CasLoop(*this, Operation::FPMax, storage_types.U32.array,
+                                storage_types.U32.element, F16[2], F16[2], spv::Scope::Device);
     }
     if (info.uses_atomic_f32x2_add) {
-        f32x2_add_cas = CasLoop(*this, Operation::FPAdd, storage_types.U32.element, F32[2], F32[2], spv::Scope::Device);
+        f32x2_add_cas = CasLoop(*this, Operation::FPAdd, storage_types.U32.array,
+                                storage_types.U32.element, F32[2], F32[2], spv::Scope::Device);
     }
     if (info.uses_atomic_f32x2_min) {
-        f32x2_min_cas = CasLoop(*this, Operation::FPMin, storage_types.U32.element, F32[2], F32[2], spv::Scope::Device);
+        f32x2_min_cas = CasLoop(*this, Operation::FPMin, storage_types.U32.array,
+                                storage_types.U32.element, F32[2], F32[2], spv::Scope::Device);
     }
     if (info.uses_atomic_f32x2_max) {
-        f32x2_max_cas = CasLoop(*this, Operation::FPMax, storage_types.U32.element, F32[2], F32[2], spv::Scope::Device);
+        f32x2_max_cas = CasLoop(*this, Operation::FPMax, storage_types.U32.array,
+                                storage_types.U32.element, F32[2], F32[2], spv::Scope::Device);
     }
 }
 

src/shader_recompiler/backend/spirv/spirv_emit_context.h

@@ -114,6 +114,7 @@ struct UniformDefinitions {
 };
 
 struct StorageTypeDefinition {
+    Id array{};
     Id element{};
 };
 
@@ -172,8 +173,6 @@ public:
     [[nodiscard]] Id BitOffset8(const IR::Value& offset);
     [[nodiscard]] Id BitOffset16(const IR::Value& offset);
 
-    [[nodiscard]] Id StoragePointer(u32 binding, Id byte_offset, const StorageTypeDefinition& type_def, u32 element_size, Id StorageDefinitions::*member_ptr);
-
     Id Const(u32 value) {
         return Constant(U32[1], value);
     }
@@ -258,11 +257,6 @@ public:
 
     std::array<UniformDefinitions, Info::MAX_CBUFS> cbufs{};
     std::array<StorageDefinitions, Info::MAX_SSBOS> ssbos{};
-    std::array<u32, Info::MAX_SSBOS> storage_buffer_mapping_bases{};
-    std::array<u32, Info::MAX_SSBOS> storage_buffer_mapping_counts{};
-    Id storage_buffer_mapping{};
-    Id storage_buffer_mapping_u32{};
-    Id storage_buffer_map_func{};
     std::vector<TextureBufferDefinition> texture_buffers;
     std::vector<ImageBufferDefinition> image_buffers;
     std::vector<TextureDefinition> textures;
@@ -382,7 +376,6 @@ public:
     bool uses_nonuniform_storage_image{};
     bool uses_nonuniform_uniform_texel_buffer{};
     bool uses_nonuniform_storage_texel_buffer{};
-    bool uses_nonuniform_storage_buffer{};
 
 private:
     void DefineCommonTypes(const Info& info);
@@ -393,7 +386,6 @@ private:
     void DefineSharedMemoryFunctions(const IR::Program& program);
     void DefineConstantBuffers(const Info& info, u32& binding);
     void DefineConstantBufferIndirectFunctions(const Info& info);
-    void DefineStorageBufferMappings(const Info& info, u32& binding);
     void DefineStorageBuffers(const Info& info, u32& binding);
     void DefineTextureBuffers(const Info& info, u32& binding);
     void DefineImageBuffers(const Info& info, u32& binding);

src/shader_recompiler/frontend/maxwell/translate_program.cpp

@@ -132,14 +132,6 @@ void AddNVNStorageBuffers(IR::Program& program) {
     }
 }
 
-void ConfigureStorageBufferMappings(IR::Program& program, const HostTranslateInfo& host_info) {
-    // https://docs.vulkan.org/guide/latest/descriptor_arrays.html
-    // will be needed: descriptor array elements represent physical spans of one guest virtual buffer.
-    for (StorageBufferDescriptor& desc : program.info.storage_buffers_descriptors) {
-        desc.count = host_info.storage_buffer_segment_count;
-    }
-}
-
 using IR::IsLegacyAttribute; //rescoped to attribute.h to make it visible in load_store_attribute.cpp IPA
 
 std::map<IR::Attribute, IR::Attribute> GenerateLegacyToGenericMappings(
@@ -307,7 +299,6 @@ IR::Program TranslateProgram(ObjectPool<IR::Inst>& inst_pool, ObjectPool<IR::Blo
     Optimization::PositionPass(env, program);
 
     Optimization::GlobalMemoryToStorageBufferPass(program, normalized_host_info);
-    ConfigureStorageBufferMappings(program, normalized_host_info);
     Optimization::TexturePass(env, program, normalized_host_info);
 
     if (Settings::values.resolution_info.active || Settings::values.rescale_hack.GetValue()) {
@@ -323,7 +314,6 @@ IR::Program TranslateProgram(ObjectPool<IR::Inst>& inst_pool, ObjectPool<IR::Blo
 
     CollectInterpolationInfo(env, program);
     AddNVNStorageBuffers(program);
-    ConfigureStorageBufferMappings(program, normalized_host_info);
     return program;
 }
 

src/shader_recompiler/host_translate_info.h

@@ -6,7 +6,6 @@
 
 #pragma once
 
-#include <algorithm>
 #include "common/common_types.h"
 
 namespace Shader {
@@ -20,7 +19,6 @@ struct HostTranslateInfo {
 
     u64 min_ssbo_alignment{};            ///< Minimum alignment supported by the device for SSBOs
     u32 max_per_stage_descriptor_sampled_images{}; ///< maximum sampled descriptors per stage
-    u32 max_per_stage_descriptor_storage_buffers{}; ///< maximum storage descriptors per stage
     u32 max_per_stage_resources{};                 ///< maximum resources per stage
     u32 max_descriptor_set_samplers{};
     u32 max_descriptor_set_uniform_buffers{};
@@ -40,14 +38,12 @@ struct HostTranslateInfo {
                                                 ///< passthrough shaders
     bool support_conditional_barrier{}; ///< True when the device supports barriers in conditional
                                         ///< control flow
-    u32 storage_buffer_segment_count{1}; ///< Physical ranges available to each guest SSBO
 
     void ApplyDescriptorLimitPolicy() noexcept {
         if (min_ssbo_alignment == 0) {
             min_ssbo_alignment = 1;
         }
         ApplyDescriptorLimitFallback(max_per_stage_descriptor_sampled_images);
-        ApplyDescriptorLimitFallback(max_per_stage_descriptor_storage_buffers);
         ApplyDescriptorLimitFallback(max_per_stage_resources);
         ApplyDescriptorLimitFallback(max_descriptor_set_samplers);
         ApplyDescriptorLimitFallback(max_descriptor_set_uniform_buffers);
@@ -57,7 +53,6 @@ struct HostTranslateInfo {
         ApplyDescriptorLimitFallback(max_descriptor_set_sampled_images);
         ApplyDescriptorLimitFallback(max_descriptor_set_storage_images);
         ApplyDescriptorLimitFallback(max_descriptor_set_input_attachements);
-        storage_buffer_segment_count = (std::max)(storage_buffer_segment_count, 1U);
     }
 
 private:

src/shader_recompiler/profile.h

@@ -64,7 +64,6 @@ struct Profile {
     bool support_storage_image_array_nonuniform_indexing{};
     bool support_uniform_texel_buffer_array_nonuniform_indexing{};
     bool support_storage_texel_buffer_array_nonuniform_indexing{};
-    bool support_storage_buffer_array_nonuniform_indexing{};
 
     bool warp_size_potentially_larger_than_guest{};
 

src/shader_recompiler/shader_info.h

@@ -6,7 +6,6 @@
 
 #pragma once
 
-#include <algorithm>
 #include <array>
 #include <bitset>
 #include <map>
@@ -341,10 +340,6 @@ struct Info {
     ImageDescriptors image_descriptors;
 };
 
-[[nodiscard]] inline bool UsesStorageBufferMappings(const Info& info) noexcept {
-    return std::ranges::any_of(info.storage_buffers_descriptors, [](const auto& desc) { return desc.count > 1; });
-}
-
 template <typename Descriptors>
 u32 NumDescriptors(const Descriptors& descriptors) {
     u32 num{};

src/tests/core/internal_network/network.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -12,16 +15,18 @@ 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{
-        Network::Domain::INET,
-        {127, 0, 0, 1},
+        16,
+        u8(Network::Domain::INET),
         1, // hopefully nobody running this test has something listening on port 1
+        {127, 0, 0, 1},
+        {},
     };
-    REQUIRE(socks[0].Connect(addr) == Network::Errno::CONNREFUSED);
+    REQUIRE(socks[0].Connect(addr) == Network::Errno::E_CONNREFUSED);
 
     std::vector<u8> 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);
 }

src/video_core/buffer_cache/buffer_cache.h

@@ -7,8 +7,6 @@
 #pragma once
 
 #include <algorithm>
-#include <cstring>
-#include <limits>
 #include <memory>
 #include <numeric>
 
@@ -425,7 +423,7 @@ void BufferCache<P>::UnbindGraphicsStorageBuffers(size_t stage) {
 
 template <class P>
 bool BufferCache<P>::BindGraphicsStorageBuffer(size_t stage, size_t ssbo_index, u32 cbuf_index,
-                                               u32 cbuf_offset, bool is_written, u32 descriptor_count) {
+                                               u32 cbuf_offset, bool is_written) {
     const bool already_enabled =
         ((channel_state->enabled_storage_buffers[stage] >> ssbo_index) & 1U) != 0;
     if constexpr (requires { runtime.ShouldLimitDynamicStorageBuffers(); }) {
@@ -450,8 +448,8 @@ bool BufferCache<P>::BindGraphicsStorageBuffer(size_t stage, size_t ssbo_index,
     const auto& cbufs = maxwell3d->state.shader_stages[stage];
     const GPUVAddr ssbo_addr = cbufs.const_buffers[cbuf_index].address + cbuf_offset;
     channel_state->storage_buffers[stage][ssbo_index] =
-        StorageBufferBinding(ssbo_addr, cbuf_index, is_written, descriptor_count);
-    return channel_state->storage_buffers[stage][ssbo_index].gpu_addr != 0;
+        StorageBufferBinding(ssbo_addr, cbuf_index, is_written);
+    return (channel_state->storage_buffers[stage][ssbo_index].buffer_id != NULL_BUFFER_ID);
 }
 
 template <class P>
@@ -489,7 +487,7 @@ void BufferCache<P>::UnbindComputeStorageBuffers() {
 
 template <class P>
 void BufferCache<P>::BindComputeStorageBuffer(size_t ssbo_index, u32 cbuf_index, u32 cbuf_offset,
-                                              bool is_written, u32 descriptor_count) {
+                                              bool is_written) {
     if (ssbo_index >= channel_state->compute_storage_buffers.size()) [[unlikely]] {
         LOG_ERROR(HW_GPU, "Storage buffer index {} exceeds maximum storage buffer count",
                   ssbo_index);
@@ -526,7 +524,7 @@ void BufferCache<P>::BindComputeStorageBuffer(size_t ssbo_index, u32 cbuf_index,
     const auto& cbufs = launch_desc.const_buffer_config;
     const GPUVAddr ssbo_addr = cbufs[cbuf_index].Address() + cbuf_offset;
     channel_state->compute_storage_buffers[ssbo_index] =
-        StorageBufferBinding(ssbo_addr, cbuf_index, is_written, descriptor_count);
+        StorageBufferBinding(ssbo_addr, cbuf_index, is_written);
 }
 
 template <class P>
@@ -1002,52 +1000,27 @@ void BufferCache<P>::BindHostGraphicsUniformBuffer(size_t stage, u32 index, u32
 
 template <class P>
 void BufferCache<P>::BindHostGraphicsStorageBuffers(size_t stage) {
-    boost::container::small_vector<u32, NUM_STORAGE_BUFFERS> segment_sizes;
-    bool uses_mapping{};
-    ForEachEnabledBit(channel_state->enabled_storage_buffers[stage], [&](u32 index) {
-        const StorageBufferBindingInfo& binding = channel_state->storage_buffers[stage][index];
-        uses_mapping |= binding.descriptor_count > 1;
-        for (u32 segment = 0; segment < binding.descriptor_count; ++segment) {
-            segment_sizes.push_back(segment < binding.segments.size() ? binding.segments[segment].size : 0);
-        }
-    });
-    if (uses_mapping) {
-        const u32 mapping_size = static_cast<u32>(segment_sizes.size() * sizeof(u32));
-        if constexpr (!IS_OPENGL) {
-            const std::span<u8> mapped = runtime.BindMappedStorageBuffer(mapping_size);
-            std::memcpy(mapped.data(), segment_sizes.data(), mapping_size);
-        }
-    }
-
     u32 binding_index = 0;
     ForEachEnabledBit(channel_state->enabled_storage_buffers[stage], [&](u32 index) {
-        const StorageBufferBindingInfo& storage = channel_state->storage_buffers[stage][index];
+        const Binding& binding = channel_state->storage_buffers[stage][index];
+        Buffer& buffer = slot_buffers[binding.buffer_id];
+        TouchBuffer(buffer, binding.buffer_id);
+        const u32 size = binding.size;
+        SynchronizeBuffer(buffer, binding.device_addr, size);
+
+        const u32 offset = buffer.Offset(binding.device_addr);
+        buffer.MarkUsage(offset, size);
         const bool is_written = ((channel_state->written_storage_buffers[stage] >> index) & 1) != 0;
-        for (u32 segment = 0; segment < storage.descriptor_count; ++segment) {
-            Buffer* buffer = &slot_buffers[NULL_BUFFER_ID];
-            u32 offset{};
-            u32 size{IS_OPENGL ? 0U : static_cast<u32>(sizeof(u32))};
-            const bool is_actual_segment = segment < storage.segments.size();
-            // shall be safe enough if the segment is not actual, use the last available segment or nullptr if none exist.
-            const Binding* binding = is_actual_segment ? &storage.segments[segment] : storage.segments.empty() ? nullptr : &storage.segments.back();
-            if (binding) {
-                buffer = &slot_buffers[binding->buffer_id];
-                size = binding->size;
-                offset = buffer->Offset(binding->device_addr);
-                if (is_actual_segment) {
-                    TouchBuffer(*buffer, binding->buffer_id);
-                    SynchronizeBuffer(*buffer, binding->device_addr, size);
-                    buffer->MarkUsage(offset, size);
-                    if (is_written) {
-                        MarkWrittenBuffer(binding->buffer_id, binding->device_addr, size);
-                    }
-                }
-            }
-            if constexpr (NEEDS_BIND_STORAGE_INDEX) {
-                runtime.BindStorageBuffer(stage, binding_index++, *buffer, offset, size, is_written);
-            } else {
-                runtime.BindStorageBuffer(*buffer, offset, size, is_written);
-            }
+
+        if (is_written) {
+            MarkWrittenBuffer(binding.buffer_id, binding.device_addr, size);
+        }
+
+        if constexpr (NEEDS_BIND_STORAGE_INDEX) {
+            runtime.BindStorageBuffer(stage, binding_index, buffer, offset, size, is_written);
+            ++binding_index;
+        } else {
+            runtime.BindStorageBuffer(buffer, offset, size, is_written);
         }
     });
 }
@@ -1163,53 +1136,28 @@ void BufferCache<P>::BindHostComputeUniformBuffers() {
 
 template <class P>
 void BufferCache<P>::BindHostComputeStorageBuffers() {
-    boost::container::small_vector<u32, NUM_STORAGE_BUFFERS> segment_sizes;
-    bool uses_mapping{};
-    ForEachEnabledBit(channel_state->enabled_compute_storage_buffers, [&](u32 index) {
-        const StorageBufferBindingInfo& binding = channel_state->compute_storage_buffers[index];
-        uses_mapping |= binding.descriptor_count > 1;
-        for (u32 segment = 0; segment < binding.descriptor_count; ++segment) {
-            segment_sizes.push_back(segment < binding.segments.size() ? binding.segments[segment].size : 0);
-        }
-    });
-    if (uses_mapping) {
-        const u32 mapping_size = static_cast<u32>(segment_sizes.size() * sizeof(u32));
-        if constexpr (!IS_OPENGL) {
-            const std::span<u8> mapped = runtime.BindMappedStorageBuffer(mapping_size);
-            std::memcpy(mapped.data(), segment_sizes.data(), mapping_size);
-        }
-    }
-
     u32 binding_index = 0;
     ForEachEnabledBit(channel_state->enabled_compute_storage_buffers, [&](u32 index) {
-        const StorageBufferBindingInfo& storage = channel_state->compute_storage_buffers[index];
+        const Binding& binding = channel_state->compute_storage_buffers[index];
+        Buffer& buffer = slot_buffers[binding.buffer_id];
+        TouchBuffer(buffer, binding.buffer_id);
+        const u32 size = binding.size;
+        SynchronizeBuffer(buffer, binding.device_addr, size);
+
+        const u32 offset = buffer.Offset(binding.device_addr);
+        buffer.MarkUsage(offset, size);
         const bool is_written =
             ((channel_state->written_compute_storage_buffers >> index) & 1) != 0;
-        for (u32 segment = 0; segment < storage.descriptor_count; ++segment) {
-            Buffer* buffer = &slot_buffers[NULL_BUFFER_ID];
-            u32 offset{};
-            u32 size{IS_OPENGL ? 0U : static_cast<u32>(sizeof(u32))};
-            const bool is_actual_segment = segment < storage.segments.size();
-            //same fallback logic
-            const Binding* binding = is_actual_segment ? &storage.segments[segment] : storage.segments.empty() ? nullptr : &storage.segments.back();
-            if (binding) {
-                buffer = &slot_buffers[binding->buffer_id];
-                size = binding->size;
-                offset = buffer->Offset(binding->device_addr);
-                if (is_actual_segment) {
-                    TouchBuffer(*buffer, binding->buffer_id);
-                    SynchronizeBuffer(*buffer, binding->device_addr, size);
-                    buffer->MarkUsage(offset, size);
-                    if (is_written) {
-                        MarkWrittenBuffer(binding->buffer_id, binding->device_addr, size);
-                    }
-                }
-            }
-            if constexpr (NEEDS_BIND_STORAGE_INDEX) {
-                runtime.BindComputeStorageBuffer(binding_index++, *buffer, offset, size, is_written);
-            } else {
-                runtime.BindStorageBuffer(*buffer, offset, size, is_written);
-            }
+
+        if (is_written) {
+            MarkWrittenBuffer(binding.buffer_id, binding.device_addr, size);
+        }
+
+        if constexpr (NEEDS_BIND_STORAGE_INDEX) {
+            runtime.BindComputeStorageBuffer(binding_index, buffer, offset, size, is_written);
+            ++binding_index;
+        } else {
+            runtime.BindStorageBuffer(buffer, offset, size, is_written);
         }
     });
 }
@@ -1402,7 +1350,10 @@ void BufferCache<P>::UpdateUniformBuffers(size_t stage) {
 template <class P>
 void BufferCache<P>::UpdateStorageBuffers(size_t stage) {
     ForEachEnabledBit(channel_state->enabled_storage_buffers[stage], [&](u32 index) {
-        UpdateStorageBuffer(channel_state->storage_buffers[stage][index]);
+        // Resolve buffer
+        Binding& binding = channel_state->storage_buffers[stage][index];
+        const BufferId buffer_id = FindBuffer(binding.device_addr, binding.size);
+        binding.buffer_id = buffer_id;
     });
 }
 
@@ -1463,54 +1414,12 @@ void BufferCache<P>::UpdateComputeUniformBuffers() {
 template <class P>
 void BufferCache<P>::UpdateComputeStorageBuffers() {
     ForEachEnabledBit(channel_state->enabled_compute_storage_buffers, [&](u32 index) {
-        UpdateStorageBuffer(channel_state->compute_storage_buffers[index]);
+        // Resolve buffer
+        Binding& binding = channel_state->compute_storage_buffers[index];
+        binding.buffer_id = FindBuffer(binding.device_addr, binding.size);
     });
 }
 
-template <class P>
-void BufferCache<P>::UpdateStorageBuffer(StorageBufferBindingInfo& binding) {
-    binding.segments.clear();
-    if (binding.gpu_addr == 0 || binding.size == 0) { return;}
-    if (binding.descriptor_count == 1) {
-        // for safety gotta preserve the legacy path on possible hosts without storage-buffer descriptor indexing.
-        const std::optional<DAddr> device_addr = gpu_memory->GpuToCpuAddress(binding.gpu_addr);
-        if (device_addr) {
-            binding.segments.push_back(Binding{
-                .device_addr = *device_addr,
-                .size = binding.size,
-                .buffer_id = FindBuffer(*device_addr, binding.size),
-            });
-        }
-        return;
-    }
-
-    const auto ranges = gpu_memory->GetSubmappedRange(binding.gpu_addr, binding.size);
-    const size_t mapped_size =
-        std::accumulate(ranges.begin(), ranges.end(), size_t{}, [](size_t total, const auto& range) { return total + range.second; });
-    if (mapped_size != binding.size) {
-        LOG_ERROR(HW_GPU, "Storage buffer range {:#x}+{:#x} is not fully mapped", binding.gpu_addr, binding.size);
-        return;
-    }
-    if (ranges.size() > binding.descriptor_count) {
-        LOG_ERROR(HW_GPU, "Storage buffer range {:#x}+{:#x} has {} physical segments, exceeding host capacity {}",
-                  binding.gpu_addr, binding.size, ranges.size(), binding.descriptor_count);
-        return;
-    }
-    for (const auto& [gpu_addr, size] : ranges) {
-        const std::optional<DAddr> device_addr = gpu_memory->GpuToCpuAddress(gpu_addr);
-        if (!device_addr || size > (std::numeric_limits<u32>::max)()) {
-            binding.segments.clear();
-            return;
-        }
-        const u32 segment_size = static_cast<u32>(size);
-        binding.segments.push_back(Binding{
-            .device_addr = *device_addr,
-            .size = segment_size,
-            .buffer_id = FindBuffer(*device_addr, segment_size),
-        });
-    }
-}
-
 template <class P>
 void BufferCache<P>::UpdateComputeTextureBuffers() {
     ForEachEnabledBit(channel_state->enabled_compute_texture_buffers, [&](u32 index) {
@@ -1932,11 +1841,6 @@ void BufferCache<P>::DeleteBuffer(BufferId buffer_id, bool do_not_mark) {
     const auto replace = [scalar_replace](std::span<Binding> bindings) {
         std::ranges::for_each(bindings, scalar_replace);
     };
-    const auto storage_replace = [scalar_replace](std::span<StorageBufferBindingInfo> bindings) {
-        for (StorageBufferBindingInfo& binding : bindings) {
-            std::ranges::for_each(binding.segments, scalar_replace);
-        }
-    };
 
     if (channel_state->index_buffer.buffer_id == buffer_id) {
         channel_state->index_buffer.buffer_id = BufferId{};
@@ -1952,10 +1856,10 @@ void BufferCache<P>::DeleteBuffer(BufferId buffer_id, bool do_not_mark) {
         }
     }
     std::ranges::for_each(channel_state->uniform_buffers, replace);
-    std::ranges::for_each(channel_state->storage_buffers, storage_replace);
+    std::ranges::for_each(channel_state->storage_buffers, replace);
     replace(channel_state->transform_feedback_buffers);
     replace(channel_state->compute_uniform_buffers);
-    storage_replace(channel_state->compute_storage_buffers);
+    replace(channel_state->compute_storage_buffers);
 
     // Mark the whole buffer as CPU written to stop tracking CPU writes
     if (!do_not_mark) {
@@ -1992,14 +1896,12 @@ void BufferCache<P>::DeleteBuffer(BufferId buffer_id, bool do_not_mark) {
 }
 
 template <class P>
-StorageBufferBindingInfo BufferCache<P>::StorageBufferBinding(GPUVAddr ssbo_addr, u32 cbuf_index,
-                                                              bool is_written, u32 descriptor_count) const {
-    // time to get rid of these null bindings
-    ASSERT(descriptor_count > 0); // shant happen
+Binding BufferCache<P>::StorageBufferBinding(GPUVAddr ssbo_addr, u32 cbuf_index,
+                                             bool is_written) const {
     const GPUVAddr gpu_addr = gpu_memory->Read<u64>(ssbo_addr);
 
     if (gpu_addr == 0) {
-        return {.descriptor_count = descriptor_count};
+        return NULL_BINDING;
     }
 
     const auto size = [&]() {
@@ -2021,17 +1923,21 @@ StorageBufferBindingInfo BufferCache<P>::StorageBufferBinding(GPUVAddr ssbo_addr
     const GPUVAddr aligned_gpu_addr = Common::AlignDown(gpu_addr, alignment);
     const u32 aligned_size = static_cast<u32>(gpu_addr - aligned_gpu_addr) + size;
 
-    if (!gpu_memory->GpuToCpuAddress(aligned_gpu_addr) || size == 0) {
+    const std::optional<DAddr> aligned_device_addr = gpu_memory->GpuToCpuAddress(aligned_gpu_addr);
+    if (!aligned_device_addr || size == 0) {
         LOG_DEBUG(HW_GPU, "Failed to find storage buffer for cbuf index {}", cbuf_index);
-        return {.descriptor_count = descriptor_count};
+        return NULL_BINDING;
     }
+    const std::optional<DAddr> device_addr = gpu_memory->GpuToCpuAddress(gpu_addr);
+    ASSERT_MSG(device_addr, "Unaligned storage buffer address not found for cbuf index {}",
+               cbuf_index);
     // The end address used for size calculation does not need to be aligned
-    const GPUVAddr gpu_end = Common::AlignUp(gpu_addr + size, Core::DEVICE_PAGESIZE);
+    const DAddr cpu_end = Common::AlignUp(*device_addr + size, Core::DEVICE_PAGESIZE);
 
-    const StorageBufferBindingInfo binding{
-        .gpu_addr = aligned_gpu_addr,
-        .size = is_written ? aligned_size : static_cast<u32>(gpu_end - aligned_gpu_addr),
-        .descriptor_count = descriptor_count,
+    const Binding binding{
+        .device_addr = *aligned_device_addr,
+        .size = is_written ? aligned_size : static_cast<u32>(cpu_end - *aligned_device_addr),
+        .buffer_id = BufferId{},
     };
     return binding;
 }

src/video_core/buffer_cache/buffer_cache_base.h

@@ -89,15 +89,6 @@ struct TextureBufferBinding : Binding {
     PixelFormat format;
 };
 
-struct StorageBufferBindingInfo {
-    // another good one: guest SSBO is a virtual interval and may span discontiguous device-memory ranges.
-    // exact case of missing character frames (high sample lane)
-    GPUVAddr gpu_addr{};
-    u32 size{};
-    u32 descriptor_count{1};
-    boost::container::small_vector<Binding, 1> segments;
-};
-
 static constexpr Binding NULL_BINDING{
     .device_addr = 0,
     .size = 0,
@@ -124,15 +115,14 @@ public:
     Binding index_buffer;
     std::array<Binding, NUM_VERTEX_BUFFERS> vertex_buffers;
     std::array<std::array<Binding, NUM_GRAPHICS_UNIFORM_BUFFERS>, NUM_STAGES> uniform_buffers;
-    std::array<std::array<StorageBufferBindingInfo, NUM_STORAGE_BUFFERS>, NUM_STAGES>
-        storage_buffers;
+    std::array<std::array<Binding, NUM_STORAGE_BUFFERS>, NUM_STAGES> storage_buffers;
     std::array<std::array<TextureBufferBinding, NUM_TEXTURE_BUFFERS>, NUM_STAGES> texture_buffers;
     std::array<Binding, NUM_TRANSFORM_FEEDBACK_BUFFERS> transform_feedback_buffers;
     Binding count_buffer_binding;
     Binding indirect_buffer_binding;
 
     std::array<Binding, NUM_COMPUTE_UNIFORM_BUFFERS> compute_uniform_buffers;
-    std::array<StorageBufferBindingInfo, NUM_STORAGE_BUFFERS> compute_storage_buffers;
+    std::array<Binding, NUM_STORAGE_BUFFERS> compute_storage_buffers;
     std::array<TextureBufferBinding, NUM_TEXTURE_BUFFERS> compute_texture_buffers;
 
     std::array<u32, NUM_STAGES> enabled_uniform_buffer_masks{};
@@ -259,7 +249,7 @@ public:
     void UnbindGraphicsStorageBuffers(size_t stage);
 
     bool BindGraphicsStorageBuffer(size_t stage, size_t ssbo_index, u32 cbuf_index, u32 cbuf_offset,
-                                   bool is_written, u32 descriptor_count = 1);
+                                   bool is_written);
 
     void UnbindGraphicsTextureBuffers(size_t stage);
 
@@ -269,7 +259,7 @@ public:
     void UnbindComputeStorageBuffers();
 
     void BindComputeStorageBuffer(size_t ssbo_index, u32 cbuf_index, u32 cbuf_offset,
-                                  bool is_written, u32 descriptor_count = 1);
+                                  bool is_written);
 
     void UnbindComputeTextureBuffers();
 
@@ -410,8 +400,6 @@ private:
 
     void UpdateStorageBuffers(size_t stage);
 
-    void UpdateStorageBuffer(StorageBufferBindingInfo& binding);
-
     void UpdateTextureBuffers(size_t stage);
 
     void UpdateTransformFeedbackBuffers();
@@ -461,9 +449,8 @@ private:
 
     void DeleteBuffer(BufferId buffer_id, bool do_not_mark = false);
 
-    [[nodiscard]] StorageBufferBindingInfo StorageBufferBinding(GPUVAddr ssbo_addr, u32 cbuf_index,
-                                                                bool is_written,
-                                                                u32 descriptor_count) const;
+    [[nodiscard]] Binding StorageBufferBinding(GPUVAddr ssbo_addr, u32 cbuf_index,
+                                               bool is_written) const;
 
     [[nodiscard]] TextureBufferBinding GetTextureBufferBinding(GPUVAddr gpu_addr, u32 size,
                                                                PixelFormat format);

src/video_core/renderer_vulkan/pipeline_helper.h

@@ -6,7 +6,6 @@
 
 #pragma once
 
-#include <array>
 #include <cstddef>
 #include <optional>
 
@@ -137,7 +136,6 @@ inline void WriteDescriptorBuffer(const Device& device, const DescriptorBufferLa
 
 [[nodiscard]] inline u32 NumDescriptorEntries(const Shader::Info& info) {
     return Shader::NumDescriptors(info.constant_buffer_descriptors) +
-           static_cast<u32>(Shader::UsesStorageBufferMappings(info)) +
            Shader::NumDescriptors(info.storage_buffers_descriptors) +
            Shader::NumDescriptors(info.texture_buffer_descriptors) +
            Shader::NumDescriptors(info.image_buffer_descriptors) +
@@ -270,12 +268,6 @@ public:
         is_compute |= (stage & VK_SHADER_STAGE_COMPUTE_BIT) != 0;
 
         Add(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, stage, info.constant_buffer_descriptors);
-        // for extra implicit storage-buffer binding required by mapped-storage-buffer support
-        if (Shader::UsesStorageBufferMappings(info)) {
-            struct Descriptor { u32 count; };
-            const std::array descriptors{Descriptor{1}};
-            Add(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, stage, descriptors);
-        }
         Add(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, stage, info.storage_buffers_descriptors);
         Add(VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, stage, info.texture_buffer_descriptors);
         Add(VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, stage, info.image_buffer_descriptors);

src/video_core/renderer_vulkan/vk_buffer_cache.cpp

@@ -695,7 +695,7 @@ vk::Buffer BufferCacheRuntime::CreateNullBuffer() {
         .flags = 0,
         .size = 4,
         .usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT |
-                 VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT,
+                 VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT,
         .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
         .queueFamilyIndexCount = 0,
         .pQueueFamilyIndices = nullptr,

src/video_core/renderer_vulkan/vk_buffer_cache.h

@@ -155,13 +155,6 @@ public:
         return ref.mapped_span;
     }
 
-    // compute/graphics new binding
-    std::span<u8> BindMappedStorageBuffer(u32 size) {
-        const StagingBufferRef ref = staging_pool.Request(size, MemoryUsage::Upload);
-        guest_descriptor_queue.AddBuffer(ref.buffer, ref.device_address, static_cast<u32>(ref.offset), size);
-        return ref.mapped_span;
-    }
-
     void BindUniformBuffer(const Buffer& buffer, u32 offset, u32 size) {
         BindBuffer(buffer, offset, size);
     }

src/video_core/renderer_vulkan/vk_compute_pipeline.cpp

@@ -157,7 +157,9 @@ bool ComputePipeline::Configure(Tegra::Engines::KeplerCompute& kepler_compute,
     buffer_cache.UnbindComputeStorageBuffers();
     size_t ssbo_index{};
     for (const auto& desc : info.storage_buffers_descriptors) {
-        buffer_cache.BindComputeStorageBuffer(ssbo_index, desc.cbuf_index, desc.cbuf_offset, desc.is_written, desc.count);
+        ASSERT(desc.count == 1);
+        buffer_cache.BindComputeStorageBuffer(ssbo_index, desc.cbuf_index, desc.cbuf_offset,
+                                              desc.is_written);
         ++ssbo_index;
     }
 

src/video_core/renderer_vulkan/vk_descriptor_pool.cpp

@@ -47,7 +47,7 @@ static DescriptorBankInfo MakeBankInfo(std::span<const Shader::Info> infos) {
     DescriptorBankInfo bank;
     for (const Shader::Info& info : infos) {
         bank.uniform_buffers += Accumulate(info.constant_buffer_descriptors);
-        bank.storage_buffers += Accumulate(info.storage_buffers_descriptors) + static_cast<u32>(Shader::UsesStorageBufferMappings(info));
+        bank.storage_buffers += Accumulate(info.storage_buffers_descriptors);
         bank.texture_buffers += Accumulate(info.texture_buffer_descriptors);
         bank.image_buffers += Accumulate(info.image_buffer_descriptors);
         bank.textures += Accumulate(info.texture_descriptors);

src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp

@@ -367,8 +367,9 @@ bool GraphicsPipeline::ConfigureImpl(bool is_indexed) {
         if constexpr (Spec::has_storage_buffers) {
             size_t ssbo_index{};
             for (const auto& desc : info.storage_buffers_descriptors) {
+                ASSERT(desc.count == 1);
                 buffer_cache.BindGraphicsStorageBuffer(stage, ssbo_index, desc.cbuf_index,
-                                                       desc.cbuf_offset, desc.is_written, desc.count);
+                                                       desc.cbuf_offset, desc.is_written);
                 ++ssbo_index;
             }
         }

src/video_core/renderer_vulkan/vk_pipeline_cache.cpp

@@ -62,12 +62,7 @@ using VideoCommon::FileEnvironment;
 using VideoCommon::GenericEnvironment;
 using VideoCommon::GraphicsEnvironment;
 
-// SPIR-V descriptor arrays require a fixed pipeline-layout count.
-// Exploration ceiling; buffer-cache telemetry records the actual physical-range demand.
-// Keep this modest because every mapped SSBO binds the full fixed array on each update.
-constexpr u32 MAX_MAPPED_STORAGE_BUFFER_DESCRIPTORS = 32;
-
-constexpr u32 CACHE_VERSION = 19;
+constexpr u32 CACHE_VERSION = 18;
 constexpr size_t VULKAN_CACHE_FLUSH_PIPELINES = 128;
 constexpr size_t VULKAN_CACHE_FLUSH_MIN_SECONDS = 30;
 constexpr std::array<char, 8> VULKAN_CACHE_MAGIC_NUMBER{'y', 'u', 'z', 'u', 'v', 'k', 'c', 'h'};
@@ -437,8 +432,6 @@ PipelineCache::PipelineCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
             device.IsUniformTexelBufferArrayNonUniformIndexingSupported(),
         .support_storage_texel_buffer_array_nonuniform_indexing =
             device.IsStorageTexelBufferArrayNonUniformIndexingSupported(),
-        .support_storage_buffer_array_nonuniform_indexing =
-            device.IsStorageBufferArrayNonUniformIndexingSupported(),
 
         .warp_size_potentially_larger_than_guest = device.IsWarpSizePotentiallyBiggerThanGuest(),
 
@@ -467,7 +460,6 @@ PipelineCache::PipelineCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
     host_info = Shader::HostTranslateInfo{
         .min_ssbo_alignment = device.GetStorageBufferAlignment(),
         .max_per_stage_descriptor_sampled_images = device.GetMaxPerStageDescriptorSampledImages(),
-        .max_per_stage_descriptor_storage_buffers = device.GetMaxPerStageDescriptorStorageBuffers(),
         .max_per_stage_resources = device.GetMaxPerStageResources(),
         .max_descriptor_set_samplers = device.GetMaxDescriptorSetSamplers(),
         .max_descriptor_set_uniform_buffers = device.GetMaxDescriptorSetUniformBuffers(),
@@ -487,20 +479,6 @@ PipelineCache::PipelineCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
         .support_viewport_index_layer = device.IsExtShaderViewportIndexLayerSupported(),
         .support_geometry_shader_passthrough = device.IsNvGeometryShaderPassthroughSupported(),
         .support_conditional_barrier = device.SupportsConditionalBarriers(),
-        .storage_buffer_segment_count = [&] {
-            if (!device.IsStorageBufferArrayNonUniformIndexingSupported()) {
-                return 1U;
-            }
-            constexpr u32 MaxGraphicsStages = static_cast<u32>(Maxwell::MaxShaderStage);
-            const auto reserve = [](u32 limit, u32 count) {
-                return limit > count ? limit - count : 0U;
-            };
-            const u32 per_stage = reserve(device.GetMaxPerStageDescriptorStorageBuffers(), 1) / static_cast<u32>(Shader::Info::MAX_SSBOS);
-            const u32 per_set = reserve(device.GetMaxDescriptorSetStorageBuffers(), MaxGraphicsStages) / (static_cast<u32>(Shader::Info::MAX_SSBOS) * MaxGraphicsStages);
-            const u32 resources = reserve(device.GetMaxPerStageResources(), 1) / (static_cast<u32>(Shader::Info::MAX_SSBOS) * 2);
-            // ensure at least one storage buffer segment is available per stage. max is still arbitrary
-            return (std::max)(1U, (std::min)({MAX_MAPPED_STORAGE_BUFFER_DESCRIPTORS, per_stage, per_set, resources}));
-        }(),
     };
     host_info.ApplyDescriptorLimitPolicy();
 

src/video_core/vulkan_common/vulkan_device.cpp

@@ -708,6 +708,7 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
         descriptor_indexing.shaderUniformTexelBufferArrayDynamicIndexing = false;
         descriptor_indexing.shaderStorageTexelBufferArrayDynamicIndexing = false;
         descriptor_indexing.shaderUniformBufferArrayNonUniformIndexing = false;
+        descriptor_indexing.shaderStorageBufferArrayNonUniformIndexing = false;
         descriptor_indexing.shaderInputAttachmentArrayNonUniformIndexing = false;
         descriptor_indexing.descriptorBindingUniformBufferUpdateAfterBind = false;
         descriptor_indexing.descriptorBindingSampledImageUpdateAfterBind = false;

src/video_core/vulkan_common/vulkan_device.h

@@ -360,7 +360,6 @@ public:
 #define FN_MAX_LIMIT_LIST \
     FN_MAX_LIMIT_ELEM(ComputeSharedMemorySize) \
     FN_MAX_LIMIT_ELEM(PerStageDescriptorSampledImages) \
-    FN_MAX_LIMIT_ELEM(PerStageDescriptorStorageBuffers) \
     FN_MAX_LIMIT_ELEM(PerStageResources) \
     FN_MAX_LIMIT_ELEM(DescriptorSetSamplers) \
     FN_MAX_LIMIT_ELEM(DescriptorSetUniformBuffers) \
@@ -416,10 +415,6 @@ FN_MAX_LIMIT_LIST
         return features.descriptor_indexing.shaderStorageTexelBufferArrayNonUniformIndexing;
     }
 
-    bool IsStorageBufferArrayNonUniformIndexingSupported() const {
-        return features.descriptor_indexing.shaderStorageBufferArrayNonUniformIndexing;
-    }
-
     /// Returns true if the device supports float64 natively.
     bool IsFloat64Supported() const {
         return features.features.shaderFloat64;