[eden-cli] rework loop to use new SDL3 event dispatch system (#4108)

modernized into the new SDL3 API for event dispatching.

also stopped using the periodic comparison and just added a SDL timer like it wants us to do
is it better than before? well it's certainly more portable now. docs say this improves battery usage on busywaits for event polling.

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

Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4108
Reviewed-by: Maufeat <sahyno1996@gmail.com>
Reviewed-by: MaranBr <maranbr@eden-emu.dev>

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -3,7 +3,7 @@ description: File a bug report
 body:
   - type: markdown
     attributes:
-      value: Tech support does not belong here. You should only file an issue here if you think you have experienced an actual bug with yuzu.
+      value: Tech support does not belong here. You should only file an issue here if you think you have experienced an actual bug with Eden.
   - type: checkboxes
     attributes:
       label: Is there an existing issue for this?
@@ -43,7 +43,7 @@ body:
     id: log
     attributes:
       label: Log File
-      description: A log file will help our developers to better diagnose and fix the issue. Instructions can be found [here](https://yuzu-emu.org/help/reference/log-files).
+      description: A log file will help our developers to better diagnose and fix the issue. Instructions can be found [here](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/docs/user/HowToAccessLogs.md).
     validations:
       required: true
   - type: textarea

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -4,7 +4,7 @@ labels: "request"
 body:
   - type: markdown
     attributes:
-      value: Tech support does not belong here. You should only file an issue here if you are requesting a feature you believe would make yuzu better.
+      value: Tech support does not belong here. You should only file an issue here if you are requesting a feature you believe would make Eden better.
   - type: checkboxes
     attributes:
       label: Is there an existing issue for this?
@@ -23,6 +23,6 @@ body:
     id: why-feature
     attributes:
       label: Why would this feature be useful?
-      description: A brief description of why this feature would make yuzu better.
+      description: A brief description of why this feature would make Eden better.
     validations:
       required: true

CMakeLists.txt

@@ -28,23 +28,23 @@ if (NOT DEFINED ARCHITECTURE)
 endif()
 
 # Needed for FFmpeg w/ VAAPI and DRM
-if (PLATFORM_OPENBSD)
+if (OPENBSD)
     # OpenBSD 7.8 broke libcxx when upgrading, so we must define the PSTL backend manually
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -I${CMAKE_SYSROOT}/usr/X11R6/include -D_LIBCPP_PSTL_BACKEND_SERIAL=1")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -I${CMAKE_SYSROOT}/usr/X11R6/include -D_LIBCPP_PSTL_BACKEND_SERIAL=1")
     set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -L${CMAKE_SYSROOT}/usr/X11R6/lib")
-elseif (PLATFORM_NETBSD)
+elseif (NETBSD)
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -I${CMAKE_SYSROOT}/usr/X11R7/include -I${CMAKE_SYSROOT}/usr/pkg/include/c++/v1")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -I${CMAKE_SYSROOT}/usr/X11R7/include -I${CMAKE_SYSROOT}/usr/pkg/include/c++/v1")
     set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -L${CMAKE_SYSROOT}/usr/X11R7/lib")
 endif()
 
 # NetBSD: Fun for the whole family!
-if (PLATFORM_NETBSD)
+if (NETBSD)
     set(ENV{PKG_CONFIG_PATH} "${PKG_CONFIG_PATH}:${CMAKE_SYSROOT}/usr/pkg/lib/ffmpeg7/pkgconfig")
 endif()
 
-cmake_dependent_option(YUZU_STATIC_ROOM "Build a static room executable only (CI only)" OFF "PLATFORM_LINUX" OFF)
+cmake_dependent_option(YUZU_STATIC_ROOM "Build a static room executable only (CI only)" OFF "LINUX" OFF)
 if (YUZU_STATIC_ROOM)
     set(YUZU_ROOM ON)
     set(YUZU_ROOM_STANDALONE ON)
@@ -224,7 +224,7 @@ endif()
 
 # ffmpeg
 option(YUZU_USE_BUNDLED_FFMPEG "Download bundled FFmpeg" ${EXT_DEFAULT})
-cmake_dependent_option(YUZU_USE_EXTERNAL_FFMPEG "Build FFmpeg from external source" "${PLATFORM_SUN}" "NOT WIN32 AND NOT ANDROID" OFF)
+cmake_dependent_option(YUZU_USE_EXTERNAL_FFMPEG "Build FFmpeg from external source" "${SOLARIS}" "NOT WIN32 AND NOT ANDROID" OFF)
 
 # sirit
 set(BUNDLED_SIRIT_DEFAULT OFF)
@@ -235,7 +235,7 @@ endif()
 option(YUZU_USE_BUNDLED_SIRIT "Download bundled sirit" ${BUNDLED_SIRIT_DEFAULT})
 
 # FreeBSD 15+ has libusb, versions below should disable it
-cmake_dependent_option(ENABLE_LIBUSB "Enable the use of LibUSB" ON "WIN32 OR PLATFORM_LINUX OR PLATFORM_FREEBSD OR APPLE" OFF)
+cmake_dependent_option(ENABLE_LIBUSB "Enable the use of LibUSB" ON "WIN32 OR LINUX OR FREEBSD OR APPLE" OFF)
 
 cmake_dependent_option(ENABLE_OPENGL "Enable OpenGL" ON "NOT (WIN32 AND ARCHITECTURE_arm64) AND NOT APPLE" OFF)
 mark_as_advanced(FORCE ENABLE_OPENGL)
@@ -249,7 +249,7 @@ option(YUZU_TESTS "Compile tests" "${BUILD_TESTING}")
 
 # Install udev rules on Linux (mainly for gyros)
 # Only acts on joysticks and nothing else.
-cmake_dependent_option(YUZU_INSTALL_UDEV_RULES "Install udev rules for gyro access" OFF "PLATFORM_LINUX" OFF)
+cmake_dependent_option(YUZU_INSTALL_UDEV_RULES "Install udev rules for gyro access" OFF "LINUX" OFF)
 
 option(YUZU_DOWNLOAD_ANDROID_VVL "Download validation layer binary for android" ON)
 
@@ -262,7 +262,7 @@ cmake_dependent_option(YUZU_ROOM_STANDALONE "Enable standalone room executable"
 
 cmake_dependent_option(YUZU_CMD "Compile the eden-cli executable" ON "NOT ANDROID" OFF)
 
-cmake_dependent_option(YUZU_CRASH_DUMPS "Compile crash dump (Minidump) support" OFF "WIN32 OR PLATFORM_LINUX" OFF)
+cmake_dependent_option(YUZU_CRASH_DUMPS "Compile crash dump (Minidump) support" OFF "WIN32 OR LINUX" OFF)
 
 option(YUZU_DOWNLOAD_TIME_ZONE_DATA "Always download time zone binaries" ON)
 set(YUZU_TZDB_PATH "" CACHE STRING "Path to a pre-downloaded timezone database")
@@ -272,7 +272,7 @@ cmake_dependent_option(YUZU_USE_BUNDLED_MOLTENVK "Download bundled MoltenVK lib"
 option(YUZU_DISABLE_LLVM "Disable LLVM (useful for CI)" OFF)
 
 set(DEFAULT_YUZU_USE_BUNDLED_OPENSSL OFF)
-if (EXT_DEFAULT OR PLATFORM_SUN OR PLATFORM_OPENBSD)
+if (EXT_DEFAULT OR SOLARIS OR OPENBSD)
     set(DEFAULT_YUZU_USE_BUNDLED_OPENSSL ON)
 endif()
 
@@ -295,7 +295,7 @@ if(EXISTS ${PROJECT_SOURCE_DIR}/hooks/pre-commit AND NOT EXISTS ${PROJECT_SOURCE
     endif()
 endif()
 
-if (ARCHITECTURE_arm64 AND (ANDROID OR PLATFORM_LINUX))
+if (ARCHITECTURE_arm64 AND (ANDROID OR LINUX))
     set(HAS_NCE 1)
     add_compile_definitions(HAS_NCE=1)
 endif()
@@ -304,7 +304,7 @@ if (YUZU_ROOM)
     add_compile_definitions(YUZU_ROOM)
 endif()
 
-if (UNIX AND NOT (PLATFORM_LINUX OR WIN32))
+if (UNIX AND NOT (LINUX OR WIN32))
     if(CXX_APPLE OR CXX_CLANG)
         # libc++ has stop_token and jthread as experimental
         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fexperimental-library")
@@ -418,7 +418,7 @@ if (Boost_ADDED)
 
     if (NOT MSVC OR CXX_CLANG)
         # boost sucks
-        if (PLATFORM_SUN)
+        if (SOLARIS)
             add_compile_options($<$<COMPILE_LANGUAGE:C,CXX>:-pthreads>)
         endif()
 
@@ -522,9 +522,9 @@ elseif (WIN32)
         # PSAPI is the Process Status API
         set(PLATFORM_LIBRARIES ${PLATFORM_LIBRARIES} psapi imm32 version crypt32 rpcrt4 gdi32 wldap32 mswsock)
     endif()
-elseif (PLATFORM_MANAGARM)
+elseif (MANAGARM)
     set(PLATFORM_LIBRARIES iconv intl)
-elseif (PLATFORM_HAIKU)
+elseif (HAIKUOS)
     # Haiku is so special :)
     set(PLATFORM_LIBRARIES bsd /boot/system/lib/libnetwork.so)
 elseif (CMAKE_SYSTEM_NAME MATCHES "^(Linux|kFreeBSD|GNU|SunOS)$")
@@ -618,7 +618,7 @@ if (ENABLE_QT)
 
     # Best practice is to ask for all components at once, so they are from the same version
     set(YUZU_QT_COMPONENTS Core Widgets Charts Concurrent Gui)
-    if (PLATFORM_LINUX OR PLATFORM_FREEBSD)
+    if (LINUX OR FREEBSD)
         list(APPEND YUZU_QT_COMPONENTS DBus)
         # yes Qt, we get it
         set(QT_NO_PRIVATE_MODULE_WARNING ON)

CMakeModules/find/FindOpus.cmake

@@ -13,7 +13,7 @@ find_package_handle_standard_args(Opus
     VERSION_VAR OPUS_VERSION
 )
 
-if (PLATFORM_MSYS)
+if (MSYS2)
     FixMsysPath(PkgConfig::OPUS)
 endif()
 

CMakeModules/find/Findenet.cmake

@@ -14,7 +14,7 @@ find_package_handle_standard_args(enet
     VERSION_VAR ENET_VERSION
 )
 
-if (PLATFORM_MSYS)
+if (MSYS2)
     FixMsysPath(PkgConfig::ENET)
 endif()
 

CMakeModules/find/Findlibusb.cmake

@@ -14,7 +14,7 @@ find_package_handle_standard_args(libusb
     VERSION_VAR LIBUSB_VERSION
 )
 
-if (PLATFORM_MSYS)
+if (MSYS2)
     FixMsysPath(PkgConfig::LIBUSB)
 endif()
 

CMakeModules/find/Findlz4.cmake

@@ -13,7 +13,7 @@ else()
     find_package(PkgConfig QUIET)
     pkg_search_module(LZ4 QUIET IMPORTED_TARGET liblz4)
 
-    if (PLATFORM_MSYS)
+    if (MSYS2)
         FixMsysPath(PkgConfig::LZ4)
     endif()
 

externals/CMakeLists.txt

@@ -164,7 +164,7 @@ if (NOT ANDROID)
         AddJsonPackage(sdl3)
     else()
         message(STATUS "Using bundled SDL3")
-        if (PLATFORM_FREEBSD)
+        if (FREEBSD)
             set(BUILD_SHARED_LIBS ON)
         endif()
         AddJsonPackage(sdl3-ci)

externals/cmake-modules/DetectPlatform.cmake

@@ -1,45 +1,46 @@
-# SPDX-FileCopyrightText: Copyright 2025 crueter
+# SPDX-FileCopyrightText: Copyright 2026 crueter
 # SPDX-License-Identifier: LGPL-3.0-or-later
 
 ## DetectPlatform ##
 
-# This is a small helper that sets PLATFORM_<platform> variables for various
+# This is a small helper that sets platform variables for various
 # operating systems and distributions. Note that Apple, Windows, Android, etc.
 # are not covered, as CMake already does that for us.
 
 # It also sets CXX_<compiler> for the C++ compiler.
 
-# Furthermore, some platforms have really silly requirements/quirks, so this
-# also does a few of those.
-
 # This module contains contributions from the Eden Emulator Project,
 # notably from crueter and Lizzie.
 
 if (${CMAKE_SYSTEM_NAME} STREQUAL "SunOS")
-    set(PLATFORM_SUN ON)
+    set(SOLARIS ON)
 elseif (${CMAKE_SYSTEM_NAME} STREQUAL "OpenOrbis")
-    set(PLATFORM_PS4 ON)
+    set(OPENORBIS ON)
 elseif (${CMAKE_SYSTEM_NAME} STREQUAL "managarm")
-    set(PLATFORM_MANAGARM ON)
-elseif (${CMAKE_SYSTEM_NAME} STREQUAL "FreeBSD")
-    set(PLATFORM_FREEBSD ON)
-elseif (${CMAKE_SYSTEM_NAME} STREQUAL "OpenBSD")
-    set(PLATFORM_OPENBSD ON)
-elseif (${CMAKE_SYSTEM_NAME} STREQUAL "NetBSD")
-    set(PLATFORM_NETBSD ON)
-elseif (${CMAKE_SYSTEM_NAME} STREQUAL "DragonFly")
-    set(PLATFORM_DRAGONFLYBSD ON)
+    set(MANAGARM ON)
 elseif (${CMAKE_SYSTEM_NAME} STREQUAL "Haiku")
-    set(PLATFORM_HAIKU ON)
-elseif (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
-    set(PLATFORM_LINUX ON)
+    set(HAIKUOS ON)
+endif()
+
+# BSD
+if (DEFINED BSD)
+    if ("${BSD}" STREQUAL "DragonFlyBSD")
+        set(DRAGONFLYBSD ON)
+    elseif ("${BSD}" STREQUAL "FreeBSD")
+        set(FREEBSD ON)
+    elseif ("${BSD}" STREQUAL "OpenBSD")
+        set(OPENBSD ON)
+    elseif ("${BSD}" STREQUAL "NetBSD")
+        set(NETBSD ON)
+    endif()
 endif()
 
 # dumb heuristic to detect msys2
 if (CMAKE_COMMAND MATCHES "msys64")
-    set(PLATFORM_MSYS ON)
+    set(MSYS2 ON)
 endif()
 
+# compiler checks
 if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
     set(CXX_CLANG ON)
     if (MSVC)
@@ -47,8 +48,6 @@ if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
     endif()
 elseif (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
     set(CXX_GCC ON)
-elseif (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
-    set(CXX_CL ON)
 elseif (CMAKE_CXX_COMPILER_ID STREQUAL "IntelLLVM")
     set(CXX_ICC ON)
 elseif (CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
@@ -61,37 +60,13 @@ if(MINGW AND CXX_CLANG)
     set(CMAKE_SYSTEM_VERSION 10.0.0)
 endif()
 
-# NB: this does not account for SPARC
-if (PLATFORM_SUN)
-    # Terrific OpenIndiana pkg shenanigans
-    list(APPEND CMAKE_PREFIX_PATH
-        "${CMAKE_SYSROOT}/usr/lib/qt/6.6/lib/amd64/cmake")
-    list(APPEND CMAKE_MODULE_PATH
-        "${CMAKE_SYSROOT}/usr/lib/qt/6.6/lib/amd64/cmake")
-
-    # Amazing - absolutely incredible
-    list(APPEND CMAKE_PREFIX_PATH "${CMAKE_SYSROOT}/usr/lib/amd64/cmake")
-    list(APPEND CMAKE_MODULE_PATH "${CMAKE_SYSROOT}/usr/lib/amd64/cmake")
-
-    # For some mighty reason, doing a normal release build sometimes
-    # may not trigger the proper -O3 switch to materialize
-    if (CMAKE_BUILD_TYPE MATCHES "Release")
-        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O3")
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3")
-    endif()
-    if (CMAKE_BUILD_TYPE MATCHES "RelWithDebInfo")
-        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O2")
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O2")
-    endif()
-endif()
-
 # MSYS2 utilities
 
 # Sometimes, PkgConfig modules will incorrectly reference / when CMake
 # wants you to reference it as C:/msys64/. This function corrects that.
 # Example in a Find module:
 #[[
-    if (PLATFORM_MSYS)
+    if (MSYS2)
         FixMsysPath(PkgConfig::OPUS)
     endif()
 ]]
@@ -116,41 +91,9 @@ function(FixMsysPath target)
         INTERFACE_INCLUDE_DIRECTORIES ${include_dir})
 endfunction()
 
-# MSYSTEM handling + program_path
-if (PLATFORM_MSYS)
-    # really, really dumb heuristic to detect what environment we are in
-    macro(system var)
-        if (CMAKE_COMMAND MATCHES ${var})
-            set(MSYSTEM ${var})
-        endif()
-    endmacro()
-
-    system(mingw64)
-    system(clang64)
-    system(clangarm64)
-    system(ucrt64)
-
-    if (NOT DEFINED MSYSTEM)
-        set(MSYSTEM msys2)
-    endif()
-
-    # We generally want to prioritize environment-specific binaries if possible
-    # some, like autoconf, are not present on environments besides msys2 though
-    set(CMAKE_PROGRAM_PATH C:/msys64/${MSYSTEM}/bin C:/msys64/usr/bin)
-    set(ENV{PKG_CONFIG_PATH} C:/msys64/${MSYSTEM}/lib/pkgconfig)
-endif()
-
-# This saves a truly ridiculous amount of time during linking
-# In my tests, without this, Eden takes 2 mins, with this, it takes 3-5 seconds
-# or on GitHub Actions, 10 minutes -> 3 seconds
+# Saves linking time
 if (MINGW)
     set(MINGW_FLAGS "-Wl,--strip-all -Wl,--gc-sections")
     set(CMAKE_EXE_LINKER_FLAGS_RELEASE
         "${CMAKE_EXE_LINKER_FLAGS_RELEASE} ${MINGW_FLAGS}")
 endif()
-
-# awesome
-if (PLATFORM_FREEBSD OR PLATFORM_DRAGONFLYBSD)
-    set(CMAKE_EXE_LINKER_FLAGS
-        "${CMAKE_EXE_LINKER_FLAGS} -L${CMAKE_SYSROOT}/usr/local/lib")
-endif()

externals/ffmpeg/CMakeLists.txt

@@ -56,7 +56,7 @@ if (NOT YUZU_USE_BUNDLED_FFMPEG)
     endif()
 endif()
 
-if (PLATFORM_PS4 OR PLATFORM_MANAGARM)
+if (OPENORBIS OR MANAGARM)
     # Doesn't support VA-API, don't go thru the embarrassment of trying to enable it
     list(APPEND FFmpeg_HWACCEL_FLAGS --disable-vaapi)
 elseif (ANDROID)
@@ -75,7 +75,7 @@ elseif (UNIX AND NOT DEFINED FFmpeg_IS_CROSS_COMPILING AND NOT ANDROID)
     if(X11_FOUND)
         if (NOT APPLE)
             # In Solaris needs explicit linking for ffmpeg which links to /lib/amd64/libX11.so
-            if(PLATFORM_SUN)
+            if(SOLARIS)
                 list(APPEND FFmpeg_HWACCEL_LIBRARIES
                     X11
                     "${CMAKE_SYSROOT}/usr/lib/xorg/amd64/libdrm.so")
@@ -158,7 +158,7 @@ elseif (UNIX AND NOT DEFINED FFmpeg_IS_CROSS_COMPILING AND NOT ANDROID)
     endif()
 endif()
 
-if (PLATFORM_PS4)
+if (OPENORBIS)
     list(APPEND FFmpeg_CROSS_COMPILE_LIBS
         -lkernel
         -lSceUserService
@@ -172,7 +172,7 @@ if (PLATFORM_PS4)
         --extra-cxxflags=${CMAKE_SYSROOT}/usr/include
         --extra-libs="${FFmpeg_CROSS_COMPILE_LIBS}"
     )
-elseif (PLATFORM_MANAGARM)
+elseif (MANAGARM)
     # Required for proper stuff
     list(APPEND FFmpeg_CROSS_COMPILE_FLAGS
         --disable-pthreads
@@ -299,7 +299,7 @@ else()
     set(FFmpeg_BUILD_LIBRARIES ${FFmpeg_LIBRARIES})
 
     # BSD make or Solaris make don't support ffmpeg make-j8
-    if (PLATFORM_LINUX OR ANDROID OR APPLE OR WIN32 OR PLATFORM_FREEBSD)
+    if (LINUX OR ANDROID OR APPLE OR WIN32 OR FREEBSD)
         set(FFmpeg_MAKE_ARGS -j${SYSTEM_THREADS})
     else()
         set(FFmpeg_MAKE_ARGS "")

externals/libusb/CMakeLists.txt

@@ -11,7 +11,7 @@ if (NOT libusb_ADDED)
 endif()
 
 # TODO: *BSD fails to compile--may need different configs/symbols
-if (MINGW OR PLATFORM_LINUX OR APPLE)
+if (MINGW OR LINUX OR APPLE)
     set(LIBUSB_FOUND ON CACHE BOOL "libusb is present" FORCE)
     set(LIBUSB_VERSION "1.0.24" CACHE STRING "libusb version string" FORCE)
 

src/CMakeLists.txt

@@ -193,7 +193,7 @@ else()
 
     if (ARCHITECTURE_x86_64)
         add_compile_options($<$<COMPILE_LANGUAGE:C,CXX>:-mcx16>)
-        if (PLATFORM_LINUX OR PLATFORM_FREEBSD)
+        if (LINUX OR FREEBSD)
             add_compile_options($<$<COMPILE_LANGUAGE:C,CXX>:-mtls-dialect=gnu2>)
         endif()
     endif()

src/common/CMakeLists.txt

@@ -108,6 +108,7 @@ 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 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 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 "core/internal_network/socket_types.h"
+#include "common/socket_types.h"
 #include "web_service/web_result.h"
 
 namespace AnnounceMultiplayerRoom {

src/common/socket_types.h

@@ -0,0 +1,178 @@
+// 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

@@ -1133,7 +1133,6 @@ 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
@@ -1174,7 +1173,7 @@ add_library(core STATIC
 
 if (ENABLE_WIFI_SCAN)
     target_sources(core PRIVATE internal_network/wifi_scanner.cpp)
-    if (PLATFORM_LINUX)
+    if (LINUX)
         target_link_libraries(core PRIVATE iw)
     endif()
 else()

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

@@ -18,7 +18,7 @@
 #include <ankerl/unordered_dense.h>
 
 #include "common/logging.h"
-#include "core/internal_network/socket_types.h"
+#include "common/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

@@ -245,6 +245,14 @@ 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,6 +1,3 @@
-// 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
 
@@ -51,6 +48,7 @@ public:
     Result ManageDeferral(Kernel::KEvent** out_event);
 
     Result LoopProcess();
+    void StartAdditionalHostThreads(const char* name, size_t num_threads);
 
     static void RunServer(std::unique_ptr<ServerManager>&& server);
 

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

@@ -12,7 +12,7 @@
 #include <fmt/ranges.h>
 
 #include "common/logging.h"
-#include "core/internal_network/socket_types.h"
+#include "common/socket_types.h"
 #include "core/core.h"
 #include "core/hle/kernel/k_thread.h"
 #include "core/hle/service/ipc_helpers.h"
@@ -28,11 +28,11 @@ namespace Service::Sockets {
 
 namespace {
 
-bool IsConnectionBased(Network::Type type) {
+bool IsConnectionBased(Type type) {
     switch (type) {
-    case Network::Type::STREAM:
+    case Type::STREAM:
         return true;
-    case Network::Type::DGRAM:
+    case Type::DGRAM:
         return false;
     default:
         UNIMPLEMENTED_MSG("Unimplemented type={}", type);
@@ -92,7 +92,7 @@ void BSD::ConnectWork::Execute(BSD* bsd) {
 void BSD::ConnectWork::Response(HLERequestContext& ctx) {
     IPC::ResponseBuilder rb{ctx, 4};
     rb.Push(ResultSuccess);
-    rb.Push<s32>(bsd_errno == Network::Errno::SUCCESS ? 0 : -1);
+    rb.Push<s32>(bsd_errno == Errno::SUCCESS ? 0 : -1);
     rb.PushEnum(bsd_errno);
 }
 
@@ -170,8 +170,12 @@ void BSD::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(Network::Domain(domain), Network::Type(type), Network::Protocol(protocol));
+
+    const auto [fd, bsd_errno] = SocketImpl(static_cast<Domain>(domain), static_cast<Type>(type),
+                                            static_cast<Protocol>(protocol));
+
     IPC::ResponseBuilder rb{ctx, 4};
     rb.Push(ResultSuccess);
     rb.Push<s32>(fd);
@@ -242,13 +246,13 @@ void BSD::GetPeerName(HLERequestContext& ctx) {
     LOG_DEBUG(Service, "called. fd={}", fd);
 
     std::vector<u8> write_buffer(ctx.GetWriteBufferSize());
-    const Network::Errno bsd_errno = GetPeerNameImpl(fd, write_buffer);
+    const Errno bsd_errno = GetPeerNameImpl(fd, write_buffer);
 
     ctx.WriteBuffer(write_buffer);
 
     IPC::ResponseBuilder rb{ctx, 5};
     rb.Push(ResultSuccess);
-    rb.Push<s32>(bsd_errno != Network::Errno::SUCCESS ? -1 : 0);
+    rb.Push<s32>(bsd_errno != Errno::SUCCESS ? -1 : 0);
     rb.PushEnum(bsd_errno);
     rb.Push<u32>(static_cast<u32>(write_buffer.size()));
 }
@@ -260,13 +264,13 @@ void BSD::GetSockName(HLERequestContext& ctx) {
     LOG_DEBUG(Service, "called. fd={}", fd);
 
     std::vector<u8> write_buffer(ctx.GetWriteBufferSize());
-    const Network::Errno bsd_errno = GetSockNameImpl(fd, write_buffer);
+    const Errno bsd_errno = GetSockNameImpl(fd, write_buffer);
 
     ctx.WriteBuffer(write_buffer);
 
     IPC::ResponseBuilder rb{ctx, 5};
     rb.Push(ResultSuccess);
-    rb.Push<s32>(bsd_errno != Network::Errno::SUCCESS ? -1 : 0);
+    rb.Push<s32>(bsd_errno != Errno::SUCCESS ? -1 : 0);
     rb.PushEnum(bsd_errno);
     rb.Push<u32>(static_cast<u32>(write_buffer.size()));
 }
@@ -274,19 +278,21 @@ void BSD::GetSockName(HLERequestContext& ctx) {
 void BSD::GetSockOpt(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const s32 fd = rp.Pop<s32>();
-    const auto level = Network::SocketLevel(rp.Pop<u32>());
-    const auto optname = Network::OptName(rp.Pop<u32>());
+    const u32 level = rp.Pop<u32>();
+    const auto optname = static_cast<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 Network::Errno err = GetSockOptImpl(fd, level, optname, optval);
+    LOG_DEBUG(Service, "called. fd={} level={} optname={:#x} len={:#x}", fd, level, optname,
+              optval.size());
+
+    const Errno err = GetSockOptImpl(fd, level, optname, optval);
 
     ctx.WriteBuffer(optval);
 
     IPC::ResponseBuilder rb{ctx, 5};
     rb.Push(ResultSuccess);
-    rb.Push<s32>(err == Network::Errno::SUCCESS ? 0 : -1);
+    rb.Push<s32>(err == Errno::SUCCESS ? 0 : -1);
     rb.PushEnum(err);
     rb.Push<u32>(static_cast<u32>(optval.size()));
 }
@@ -309,7 +315,7 @@ void BSD::Fcntl(HLERequestContext& ctx) {
 
     LOG_DEBUG(Service, "called. fd={} cmd={} arg={}", fd, cmd, arg);
 
-    const auto [ret, bsd_errno] = FcntlImpl(fd, Network::FcntlCmd(cmd), arg);
+    const auto [ret, bsd_errno] = FcntlImpl(fd, static_cast<FcntlCmd>(cmd), arg);
 
     IPC::ResponseBuilder rb{ctx, 4};
     rb.Push(ResultSuccess);
@@ -321,11 +327,13 @@ void BSD::SetSockOpt(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
 
     const s32 fd = rp.Pop<s32>();
-    const Network::SocketLevel level = Network::SocketLevel(rp.Pop<u32>());
-    const Network::OptName optname = Network::OptName(rp.Pop<u32>());
+    const u32 level = rp.Pop<u32>();
+    const OptName optname = static_cast<OptName>(rp.Pop<u32>());
     const auto optval = ctx.ReadBuffer();
 
-    LOG_DEBUG(Service, "called. fd={} level={} optname={:#x} optlen={}", fd, level, u32(optname), optval.size());
+    LOG_DEBUG(Service, "called. fd={} level={} optname={:#x} optlen={}", fd, level,
+              static_cast<u32>(optname), optval.size());
+
     BuildErrnoResponse(ctx, SetSockOptImpl(fd, level, optname, optval));
 }
 
@@ -446,7 +454,7 @@ void BSD::DuplicateSocket(HLERequestContext& ctx) {
 
     struct OutputParameters {
         s32 ret;
-        Network::Errno bsd_errno;
+        Errno bsd_errno;
     };
     static_assert(sizeof(OutputParameters) == 0x8);
 
@@ -460,10 +468,10 @@ void BSD::DuplicateSocket(HLERequestContext& ctx) {
     if (auto* res = std::get_if<s32>(&res_v)) {
         rb.PushRaw(OutputParameters{
             .ret = *res,
-            .bsd_errno = Network::Errno::SUCCESS,
+            .bsd_errno = Errno::SUCCESS,
         });
     } else {
-        auto* err = std::get_if<Network::Errno>(&res_v);
+        auto* err = std::get_if<Errno>(&res_v);
         rb.PushRaw(OutputParameters{
             .ret = 0,
             .bsd_errno = *err,
@@ -478,7 +486,7 @@ void BSD::EventFd(HLERequestContext& ctx) {
 
     LOG_WARNING(Service, "(STUBBED) called. initval={}, flags={}", initval, flags);
 
-    BuildErrnoResponse(ctx, Network::Errno::SUCCESS);
+    BuildErrnoResponse(ctx, Errno::SUCCESS);
 }
 
 template <typename Work>
@@ -487,35 +495,29 @@ void BSD::ExecuteWork(HLERequestContext& ctx, Work work) {
     work.Response(ctx);
 }
 
-std::pair<s32, Network::Errno> BSD::SocketImpl(Network::Domain domain, Network::Type type, Network::Protocol protocol) {
-    LOG_DEBUG(Network, "domain={},type,protocol={}", u32(domain), u32(type), u32(protocol));
-    if (type == Network::Type::SEQPACKET) {
+std::pair<s32, Errno> BSD::SocketImpl(Domain domain, Type type, Protocol protocol) {
+
+    if (type == Type::SEQPACKET) {
         UNIMPLEMENTED_MSG("SOCK_SEQPACKET errno management");
-    } else if (type == Network::Type::RAW && (domain != Network::Domain::INET || protocol != Network::Protocol::ICMP)) {
+    } else if (type == Type::RAW && (domain != Domain::INET || protocol != Protocol::ICMP)) {
         UNIMPLEMENTED_MSG("SOCK_RAW errno management");
     }
 
-    [[maybe_unused]] const bool unk_flag = (u32(type) & 0x20000000) != 0;
+    [[maybe_unused]] const bool unk_flag = (static_cast<u32>(type) & 0x20000000) != 0;
     UNIMPLEMENTED_IF_MSG(unk_flag, "Unknown flag in type");
-    type = Network::Type(u32(type) & ~0x20000000);
+    type = static_cast<Type>(static_cast<u32>(type) & ~0x20000000);
 
     const s32 fd = FindFreeFileDescriptorHandle();
     if (fd < 0) {
         LOG_ERROR(Service, "No more file descriptors available");
-        return {-1, Network::Errno::MFILE};
-    }
-
-    if (Settings::values.airplane_mode.GetValue() && IsConnectionBased(type)) {
-        LOG_ERROR(Service, "Airplane mode is enabled, cannot create socket");
-        file_descriptors[fd].reset();
-        return {-1, Network::Errno::NOTCONN};
+        return {-1, Errno::MFILE};
     }
 
     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);
 
     auto room_member = Network::GetRoomMember().lock();
     if (room_member && room_member->IsConnected()) {
@@ -523,89 +525,100 @@ std::pair<s32, Network::Errno> BSD::SocketImpl(Network::Domain domain, Network::
     } 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);
-#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};
+
+    if (Settings::values.airplane_mode.GetValue() && descriptor.is_connection_based) {
+        LOG_ERROR(Service, "Airplane mode is enabled, cannot create socket");
+        return {-1, Errno::NOTCONN};
     }
-    return {fd, Network::Errno::SUCCESS};
+
+    return {fd, Errno::SUCCESS};
 }
 
-std::pair<s32, Network::Errno> BSD::PollImpl(std::vector<u8>& write_buffer, std::span<const u8> read_buffer, s32 nfds, s32 timeout) {
-    LOG_DEBUG(Network, "nfds={},timeout={}", nfds, timeout);
+std::pair<s32, Errno> BSD::PollImpl(std::vector<u8>& write_buffer, std::span<const u8> read_buffer,
+                                    s32 nfds, s32 timeout) {
     if (nfds <= 0) {
         // When no entries are provided, -1 is returned with errno zero
-        return {-1, Network::Errno::SUCCESS};
+        return {-1, Errno::SUCCESS};
     }
-    if (read_buffer.size() < nfds * sizeof(Network::PollFD)) {
-        return {-1, Network::Errno::INVAL};
+    if (read_buffer.size() < nfds * sizeof(PollFD)) {
+        return {-1, Errno::INVAL};
     }
-    if (write_buffer.size() < nfds * sizeof(Network::PollFD)) {
-        return {-1, Network::Errno::INVAL};
+    if (write_buffer.size() < nfds * sizeof(PollFD)) {
+        return {-1, Errno::INVAL};
     }
 
-    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());
+    std::vector<PollFD> fds(nfds);
+    std::memcpy(fds.data(), read_buffer.data(), nfds * sizeof(PollFD));
 
     if (timeout >= 0) {
         const s64 seconds = timeout / 1000;
-        const u64 nanoseconds = 1'000'000 * (u64(timeout) % 1000);
+        const u64 nanoseconds = 1'000'000 * (static_cast<u64>(timeout) % 1000);
+
         if (seconds < 0) {
-            return {-1, Network::Errno::INVAL};
+            return {-1, Errno::INVAL};
         }
         if (nanoseconds > 999'999'999) {
-            return {-1, Network::Errno::INVAL};
+            return {-1, Errno::INVAL};
         }
     } else if (timeout != -1) {
-        return {-1, Network::Errno::INVAL};
+        return {-1, Errno::INVAL};
     }
 
-    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::SUCCESS};
+    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};
         }
     }
 
-    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 = {};
+    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{};
         return 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;
+
+    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);
 }
 
-std::pair<s32, Network::Errno> BSD::AcceptImpl(s32 fd, std::vector<u8>& write_buffer) {
-    LOG_DEBUG(Network, "fd={}", fd);
+std::pair<s32, Errno> BSD::AcceptImpl(s32 fd, std::vector<u8>& write_buffer) {
     if (!IsFileDescriptorValid(fd)) {
-        return {-1, Network::Errno::BADF};
+        return {-1, Errno::BADF};
     }
 
     const s32 new_fd = FindFreeFileDescriptorHandle();
     if (new_fd < 0) {
         LOG_ERROR(Service, "No more file descriptors available");
-        return {-1, Network::Errno::MFILE};
+        return {-1, Errno::MFILE};
     }
 
     FileDescriptor& descriptor = *file_descriptors[fd];
     auto [result, bsd_errno] = descriptor.socket->Accept();
     if (bsd_errno != Network::Errno::SUCCESS) {
-        return {-1, bsd_errno};
+        return {-1, Translate(bsd_errno)};
     }
 
     file_descriptors[new_fd] = FileDescriptor{};
@@ -613,218 +626,267 @@ std::pair<s32, Network::Errno> BSD::AcceptImpl(s32 fd, std::vector<u8>& write_bu
     new_descriptor.socket = std::move(result.socket);
     new_descriptor.is_connection_based = descriptor.is_connection_based;
 
-    PutValue(write_buffer, result.sockaddr_in);
-    return {new_fd, Network::Errno::SUCCESS};
+    const SockAddrIn guest_addr_in = Translate(result.sockaddr_in);
+    PutValue(write_buffer, guest_addr_in);
+
+    return {new_fd, Errno::SUCCESS};
 }
 
-Network::Errno BSD::BindImpl(s32 fd, std::span<const u8> addr) {
-    LOG_DEBUG(Network, "fd={}", fd);
+Errno BSD::BindImpl(s32 fd, std::span<const u8> addr) {
     if (!IsFileDescriptorValid(fd)) {
-        return Network::Errno::BADF;
+        return Errno::BADF;
     }
     ASSERT(addr.size() >= 16);
     if (!file_descriptors[fd]->socket) {
         LOG_WARNING(Service, "Uninitialized socket");
-        return Network::Errno::BADF;
+        return Errno::BADF;
     }
 
-    auto addr_in = GetValue<Network::SockAddrIn>(addr);
-    return file_descriptors[fd]->socket->Bind(addr_in);
+    auto addr_in = GetValue<SockAddrIn>(addr);
+
+    return Translate(file_descriptors[fd]->socket->Bind(Translate(addr_in)));
 }
 
-Network::Errno BSD::ConnectImpl(s32 fd, std::span<const u8> addr) {
-    LOG_DEBUG(Network, "fd={}", fd);
+Errno BSD::ConnectImpl(s32 fd, std::span<const u8> addr) {
     if (!IsFileDescriptorValid(fd)) {
-        return Network::Errno::BADF;
+        return Errno::BADF;
     }
 
     ASSERT(addr.size() >= 16);
     if (!file_descriptors[fd]->socket) {
         LOG_WARNING(Service, "Uninitialized socket");
-        return Network::Errno::BADF;
+        return Errno::BADF;
     }
 
-    auto addr_in = GetValue<Network::SockAddrIn>(addr);
-    const Network::Errno result = file_descriptors[fd]->socket->Connect(addr_in);
-    if (result == Network::Errno::ISCONN) {
+    auto addr_in = GetValue<SockAddrIn>(addr);
+
+    const Errno result = Translate(file_descriptors[fd]->socket->Connect(Translate(addr_in)));
+
+    if (result == Errno::ISCONN) {
         LOG_DEBUG(Service, "returned ISCONN - socket already connected");
-        return Network::Errno::SUCCESS;
+        return Errno::SUCCESS;
     }
 
     return result;
 }
 
-Network::Errno BSD::GetPeerNameImpl(s32 fd, std::vector<u8>& write_buffer) {
-    LOG_DEBUG(Network, "fd={}", fd);
+Errno BSD::GetPeerNameImpl(s32 fd, std::vector<u8>& write_buffer) {
     if (!IsFileDescriptorValid(fd)) {
-        return Network::Errno::BADF;
+        return Errno::BADF;
     }
 
     if (!file_descriptors[fd]->socket) {
         LOG_WARNING(Service, "Uninitialized socket");
-        return Network::Errno::BADF;
+        return Errno::BADF;
     }
 
     const auto [addr_in, bsd_errno] = file_descriptors[fd]->socket->GetPeerName();
     if (bsd_errno != Network::Errno::SUCCESS) {
-        return bsd_errno;
+        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;
+    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);
 }
 
-Network::Errno BSD::GetSockNameImpl(s32 fd, std::vector<u8>& write_buffer) {
-    LOG_DEBUG(Network, "fd={}", fd);
+Errno BSD::GetSockNameImpl(s32 fd, std::vector<u8>& write_buffer) {
     if (!IsFileDescriptorValid(fd)) {
-        return Network::Errno::BADF;
+        return Errno::BADF;
     }
 
     if (!file_descriptors[fd]->socket) {
         LOG_WARNING(Service, "Uninitialized socket");
-        return Network::Errno::BADF;
+        return Errno::BADF;
     }
 
     const auto [addr_in, bsd_errno] = file_descriptors[fd]->socket->GetSockName();
     if (bsd_errno != Network::Errno::SUCCESS) {
-        return bsd_errno;
+        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;
+    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);
 }
 
-Network::Errno BSD::ListenImpl(s32 fd, s32 backlog) {
-    LOG_DEBUG(Network, "fd={},backlog={}", fd, backlog);
+Errno BSD::ListenImpl(s32 fd, s32 backlog) {
     if (!IsFileDescriptorValid(fd)) {
-        return Network::Errno::BADF;
+        return Errno::BADF;
     }
     if (!file_descriptors[fd]->socket) {
         LOG_WARNING(Service, "Uninitialized socket");
-        return Network::Errno::BADF;
+        return Errno::BADF;
     }
-    return file_descriptors[fd]->socket->Listen(backlog);
+    return Translate(file_descriptors[fd]->socket->Listen(backlog));
 }
 
-std::pair<s32, Network::Errno> BSD::FcntlImpl(s32 fd, Network::FcntlCmd cmd, s32 arg) {
-    LOG_DEBUG(Network, "fd={},cmd={},arg={}", fd, u32(cmd), arg);
+std::pair<s32, Errno> BSD::FcntlImpl(s32 fd, FcntlCmd cmd, s32 arg) {
     if (!IsFileDescriptorValid(fd)) {
-        return {-1, Network::Errno::BADF};
+        return {-1, Errno::BADF};
     }
     if (!file_descriptors[fd]->socket) {
         LOG_WARNING(Service, "Uninitialized socket");
-        return {-1, Network::Errno::BADF};
+        return {-1, Errno::BADF};
     }
 
     FileDescriptor& descriptor = *file_descriptors[fd];
+
     switch (cmd) {
-    case Network::FcntlCmd::GETFL:
+    case FcntlCmd::GETFL:
         ASSERT(arg == 0);
-        return {descriptor.flags, Network::Errno::SUCCESS};
-    case Network::FcntlCmd::SETFL: {
-        const bool enable = (arg & u32(Network::FcntlFlags::NONBLOCK_NX)) != 0;
-        const Network::Errno bsd_errno = descriptor.socket->SetNonBlock(enable);
-        if (bsd_errno != Network::Errno::SUCCESS) {
+        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 {-1, bsd_errno};
         }
         descriptor.flags = arg;
-        return {0, Network::Errno::SUCCESS};
+        return {0, Errno::SUCCESS};
     }
     default:
         UNIMPLEMENTED_MSG("Unimplemented cmd={}", cmd);
-        return {-1, Network::Errno::SUCCESS};
+        return {-1, Errno::SUCCESS};
     }
 }
 
-Network::Errno BSD::GetSockOptImpl(s32 fd, Network::SocketLevel level, Network::OptName optname, std::vector<u8>& optval) {
-    LOG_DEBUG(Network, "fd={},level={},optname={}", fd, u32(level), u32(optname));
+Errno BSD::GetSockOptImpl(s32 fd, u32 level, OptName optname, std::vector<u8>& optval) {
     if (!IsFileDescriptorValid(fd)) {
-        return Network::Errno::BADF;
+        return Errno::BADF;
     }
     if (!file_descriptors[fd]->socket) {
         LOG_WARNING(Service, "Uninitialized socket");
-        return Network::Errno::BADF;
+        return Errno::BADF;
     }
 
-    if (level != Network::SocketLevel::SOCKET) {
-        LOG_WARNING(Service, "(stubbed) level fd={}, level={}, optname={}", fd, level, optname);
+    if (level != static_cast<u32>(SocketLevel::SOCKET)) {
+        UNIMPLEMENTED_MSG("Unknown getsockopt level");
+        return Errno::SUCCESS;
     }
 
     Network::SocketBase* const socket = file_descriptors[fd]->socket.get();
 
     switch (optname) {
-    case Network::OptName::ERROR_: {
+    case OptName::ERROR_: {
         auto [pending_err, getsockopt_err] = socket->GetPendingError();
         if (getsockopt_err == Network::Errno::SUCCESS) {
+            Errno translated_pending_err = Translate(pending_err);
             ASSERT_OR_EXECUTE_MSG(
-                optval.size() == sizeof(Network::Errno), { return Network::Errno::INVAL; },
+                optval.size() == sizeof(Errno), { return Errno::INVAL; },
                 "Incorrect getsockopt option size");
-            optval.resize(sizeof(Network::Errno));
-            PutValue(optval, pending_err);
+            optval.resize(sizeof(Errno));
+            PutValue(optval, translated_pending_err);
         }
-        return getsockopt_err;
+        return Translate(getsockopt_err);
     }
     default:
         UNIMPLEMENTED_MSG("Unimplemented optname={}", optname);
-        return Network::Errno::SUCCESS;
+        return Errno::SUCCESS;
     }
 }
 
-Network::Errno BSD::SetSockOptImpl(s32 fd, Network::SocketLevel level, Network::OptName optname, std::span<const u8> optval) {
-    LOG_DEBUG(Service, "fd={},level={},optname={}", fd, level, optname);
+Errno BSD::SetSockOptImpl(s32 fd, u32 level, OptName optname, std::span<const u8> optval) {
     if (!IsFileDescriptorValid(fd)) {
-        return Network::Errno::BADF;
+        return Errno::BADF;
     }
     if (!file_descriptors[fd]->socket) {
         LOG_WARNING(Service, "Uninitialized socket");
-        return Network::Errno::BADF;
+        return Errno::BADF;
+    }
+
+    if (level != static_cast<u32>(SocketLevel::SOCKET)) {
+        LOG_WARNING(Service, "(STUBBED) setsockopt with level={}, optname={}", level, optname);
+        return Errno::SUCCESS;
     }
 
     Network::SocketBase* const socket = file_descriptors[fd]->socket.get();
-    return socket->SetSockOpt(level, optname, optval);
+
+    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;
+    }
 }
 
-Network::Errno BSD::ShutdownImpl(s32 fd, s32 how) {
-    LOG_DEBUG(Network, "fd={},how={}", fd, how);
+Errno BSD::ShutdownImpl(s32 fd, s32 how) {
     if (!IsFileDescriptorValid(fd)) {
-        return Network::Errno::BADF;
+        return Errno::BADF;
     }
     if (!file_descriptors[fd]->socket) {
         LOG_WARNING(Service, "Uninitialized socket");
-        return Network::Errno::BADF;
+        return Errno::BADF;
     }
-    return file_descriptors[fd]->socket->Shutdown(Network::ShutdownHow(how));
+    const Network::ShutdownHow host_how = Translate(static_cast<ShutdownHow>(how));
+    return Translate(file_descriptors[fd]->socket->Shutdown(host_how));
 }
 
-std::pair<s32, Network::Errno> BSD::RecvImpl(s32 fd, u32 flags, std::vector<u8>& message) {
-    LOG_DEBUG(Network, "fd={},flags={}", fd, flags);
+std::pair<s32, Errno> BSD::RecvImpl(s32 fd, u32 flags, std::vector<u8>& message) {
     if (!IsFileDescriptorValid(fd)) {
-        return {-1, Network::Errno::BADF};
+        return {-1, Errno::BADF};
     }
 
     FileDescriptor& descriptor = *file_descriptors[fd];
 
     // Apply flags
-    if ((flags & u32(Network::MsgOpt::DONTWAIT)) != 0) {
-        flags &= ~u32(Network::MsgOpt::DONTWAIT);
-        if ((descriptor.flags & u32(Network::FcntlFlags::NONBLOCK_NX)) == 0) {
+    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) {
             descriptor.socket->SetNonBlock(true);
         }
     }
 
-    const auto [ret, bsd_errno] = descriptor.socket->Recv(flags, message);
+    const auto [ret, bsd_errno] = Translate(descriptor.socket->Recv(flags, message));
+
     // Restore original state
-    if ((descriptor.flags & u32(Network::FcntlFlags::NONBLOCK_NX)) == 0)
+    if ((descriptor.flags & FLAG_O_NONBLOCK) == 0) {
         descriptor.socket->SetNonBlock(false);
+    }
+
     return {ret, bsd_errno};
 }
 
-std::pair<s32, Network::Errno> BSD::RecvFromImpl(s32 fd, u32 flags, std::vector<u8>& message, std::vector<u8>& addr) {
-    LOG_DEBUG(Network, "fd={},flags={}", fd, flags);
+std::pair<s32, Errno> BSD::RecvFromImpl(s32 fd, u32 flags, std::vector<u8>& message,
+                                        std::vector<u8>& addr) {
     if (!IsFileDescriptorValid(fd)) {
-        return {-1, Network::Errno::BADF};
+        return {-1, Errno::BADF};
     }
 
     FileDescriptor& descriptor = *file_descriptors[fd];
@@ -839,17 +901,19 @@ std::pair<s32, Network::Errno> BSD::RecvFromImpl(s32 fd, u32 flags, std::vector<
     }
 
     // Apply flags
-    if ((flags & u32(Network::MsgOpt::DONTWAIT)) != 0) {
-        flags &= ~u32(Network::MsgOpt::DONTWAIT);
-        if ((descriptor.flags & u32(Network::FcntlFlags::NONBLOCK_NX)) == 0) {
+    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) {
             descriptor.socket->SetNonBlock(true);
         }
     }
 
-    const auto [ret, bsd_errno] = descriptor.socket->RecvFrom(flags, message, p_addr_in);
+    const auto [ret, bsd_errno] = Translate(descriptor.socket->RecvFrom(flags, message, p_addr_in));
 
     // Restore original state
-    if ((descriptor.flags & u32(Network::FcntlFlags::NONBLOCK_NX)) == 0) {
+    if ((descriptor.flags & FLAG_O_NONBLOCK) == 0) {
         descriptor.socket->SetNonBlock(false);
     }
 
@@ -858,59 +922,58 @@ std::pair<s32, Network::Errno> BSD::RecvFromImpl(s32 fd, u32 flags, std::vector<
             addr.clear();
         } else {
             ASSERT(addr.size() >= 16);
-            PutValue(addr, addr_in);
+            const SockAddrIn result = Translate(addr_in);
+            PutValue(addr, result);
         }
     }
 
     return {ret, bsd_errno};
 }
 
-std::pair<s32, Network::Errno> BSD::SendImpl(s32 fd, u32 flags, std::span<const u8> message) {
-    LOG_DEBUG(Network, "fd={},flags={}", fd, flags);
+std::pair<s32, Errno> BSD::SendImpl(s32 fd, u32 flags, std::span<const u8> message) {
     if (!IsFileDescriptorValid(fd)) {
-        return {-1, Network::Errno::BADF};
+        return {-1, Errno::BADF};
     }
     if (!file_descriptors[fd]->socket) {
         LOG_WARNING(Service, "Uninitialized socket");
-        return {-1, Network::Errno::BADF};
+        return {-1, Errno::BADF};
     }
-    return file_descriptors[fd]->socket->Send(message, flags);
+    return Translate(file_descriptors[fd]->socket->Send(message, flags));
 }
 
-std::pair<s32, Network::Errno> BSD::SendToImpl(s32 fd, u32 flags, std::span<const u8> message, std::span<const u8> addr) {
-    LOG_DEBUG(Network, "fd={},flags={}", fd, flags);
+std::pair<s32, Errno> BSD::SendToImpl(s32 fd, u32 flags, std::span<const u8> message,
+                                      std::span<const u8> addr) {
     if (!IsFileDescriptorValid(fd)) {
-        return {-1, Network::Errno::BADF};
+        return {-1, Errno::BADF};
     }
     if (!file_descriptors[fd]->socket) {
         LOG_WARNING(Service, "Uninitialized socket");
-        return {-1, Network::Errno::BADF};
+        return {-1, Errno::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<Network::SockAddrIn>(addr);
-        addr_in = guest_addr_in;
+        auto guest_addr_in = GetValue<SockAddrIn>(addr);
+        addr_in = Translate(guest_addr_in);
         p_addr_in = &addr_in;
     }
 
-    return file_descriptors[fd]->socket->SendTo(flags, message, p_addr_in);
+    return Translate(file_descriptors[fd]->socket->SendTo(flags, message, p_addr_in));
 }
 
-Network::Errno BSD::CloseImpl(s32 fd) {
-    LOG_DEBUG(Network, "fd={}", fd);
+Errno BSD::CloseImpl(s32 fd) {
     if (!IsFileDescriptorValid(fd)) {
-        return Network::Errno::BADF;
+        return Errno::BADF;
     }
     if (!file_descriptors[fd]->socket) {
         LOG_WARNING(Service, "Uninitialized socket");
-        return Network::Errno::BADF;
+        return Errno::BADF;
     }
 
-    auto const bsd_errno = file_descriptors[fd]->socket->Close();
-    if (bsd_errno != Network::Errno::SUCCESS) {
+    const Errno bsd_errno = Translate(file_descriptors[fd]->socket->Close());
+    if (bsd_errno != Errno::SUCCESS) {
         return bsd_errno;
     }
 
@@ -920,16 +983,15 @@ Network::Errno BSD::CloseImpl(s32 fd) {
     return bsd_errno;
 }
 
-std::variant<s32, Network::Errno> BSD::DuplicateSocketImpl(s32 fd) {
-    LOG_DEBUG(Network, "fd={}", fd);
+std::variant<s32, Errno> BSD::DuplicateSocketImpl(s32 fd) {
     if (!IsFileDescriptorValid(fd)) {
-        return Network::Errno::BADF;
+        return Errno::BADF;
     }
 
     const s32 new_fd = FindFreeFileDescriptorHandle();
-    if (!IsFileDescriptorValid(new_fd)) {
+    if (new_fd < 0) {
         LOG_ERROR(Service, "No more file descriptors available");
-        return Network::Errno::MFILE;
+        return Errno::MFILE;
     }
 
     file_descriptors[new_fd] = FileDescriptor{
@@ -941,7 +1003,6 @@ std::variant<s32, Network::Errno> BSD::DuplicateSocketImpl(s32 fd) {
 }
 
 std::optional<std::shared_ptr<Network::SocketBase>> BSD::GetSocket(s32 fd) {
-    LOG_DEBUG(Network, "fd={}", fd);
     if (!IsFileDescriptorValid(fd)) {
         return std::nullopt;
     }
@@ -953,40 +1014,41 @@ std::optional<std::shared_ptr<Network::SocketBase>> BSD::GetSocket(s32 fd) {
 }
 
 s32 BSD::FindFreeFileDescriptorHandle() noexcept {
-    // 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])
+    for (s32 fd = 0; fd < static_cast<s32>(file_descriptors.size()); ++fd) {
+        if (!file_descriptors[fd]) {
             return fd;
+        }
+    }
     return -1;
 }
 
 bool BSD::IsFileDescriptorValid(s32 fd) const noexcept {
-    if (fd < 0 || fd >= s32(file_descriptors.size())) {
-        LOG_ERROR(Service, "Invalid handle={}", fd);
+    if (fd > static_cast<s32>(MAX_FD) || fd < 0) {
+        LOG_ERROR(Service, "Invalid file descriptor handle={}", fd);
         return false;
     }
     if (!file_descriptors[fd]) {
-        LOG_ERROR(Service, "handle={} is not allocated", fd);
+        LOG_ERROR(Service, "File descriptor handle={} is not allocated", fd);
         return false;
     }
     return true;
 }
 
-void BSD::BuildErrnoResponse(HLERequestContext& ctx, Network::Errno bsd_errno) const noexcept {
+void BSD::BuildErrnoResponse(HLERequestContext& ctx, Errno bsd_errno) const noexcept {
     IPC::ResponseBuilder rb{ctx, 4};
 
     rb.Push(ResultSuccess);
-    rb.Push<s32>(bsd_errno == Network::Errno::SUCCESS ? 0 : -1);
+    rb.Push<s32>(bsd_errno == Errno::SUCCESS ? 0 : -1);
     rb.PushEnum(bsd_errno);
 }
 
 void BSD::OnProxyPacketReceived(const Network::ProxyPacket& packet) {
     for (auto& optional_descriptor : file_descriptors) {
-        if (optional_descriptor.has_value()) {
-            FileDescriptor& descriptor = *optional_descriptor;
-            descriptor.socket.get()->HandleProxyPacket(packet);
+        if (!optional_descriptor.has_value()) {
+            continue;
         }
+        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 "core/internal_network/socket_types.h"
+#include "common/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, Network::Errno> DuplicateSocketImpl(s32 fd);
-    Network::Errno CloseImpl(s32 fd);
+    std::variant<s32, Errno> DuplicateSocketImpl(s32 fd);
+    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{};
-        Network::Errno bsd_errno{};
+        Errno bsd_errno{};
     };
 
     struct AcceptWork {
@@ -68,7 +68,7 @@ private:
         s32 fd;
         std::vector<u8> write_buffer;
         s32 ret{};
-        Network::Errno bsd_errno{};
+        Errno bsd_errno{};
     };
 
     struct ConnectWork {
@@ -77,7 +77,7 @@ private:
 
         s32 fd;
         std::span<const u8> addr;
-        Network::Errno bsd_errno{};
+        Errno bsd_errno{};
     };
 
     struct RecvWork {
@@ -88,7 +88,7 @@ private:
         u32 flags;
         std::vector<u8> message;
         s32 ret{};
-        Network::Errno bsd_errno{};
+        Errno bsd_errno{};
     };
 
     struct RecvFromWork {
@@ -100,7 +100,7 @@ private:
         std::vector<u8> message;
         std::vector<u8> addr;
         s32 ret{};
-        Network::Errno bsd_errno{};
+        Errno bsd_errno{};
     };
 
     struct SendWork {
@@ -111,7 +111,7 @@ private:
         u32 flags;
         std::span<const u8> message;
         s32 ret{};
-        Network::Errno bsd_errno{};
+        Errno bsd_errno{};
     };
 
     struct SendToWork {
@@ -123,7 +123,7 @@ private:
         std::span<const u8> message;
         std::span<const u8> addr;
         s32 ret{};
-        Network::Errno bsd_errno{};
+        Errno bsd_errno{};
     };
 
     void RegisterClient(HLERequestContext& ctx);
@@ -154,30 +154,30 @@ private:
     template <typename Work>
     void ExecuteWork(HLERequestContext& ctx, Work work);
 
-    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,
+    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, 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::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::vector<u8>& addr);
-    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::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::span<const u8> addr);
 
     s32 FindFreeFileDescriptorHandle() noexcept;
     bool IsFileDescriptorValid(s32 fd) const noexcept;
 
-    void BuildErrnoResponse(HLERequestContext& ctx, Network::Errno bsd_errno) const noexcept;
+    void BuildErrnoResponse(HLERequestContext& ctx, 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(Network::GetAddrInfoError result) {
+static NetDbError GetAddrInfoErrorToNetDbError(GetAddrInfoError result) {
     // These combinations have been verified on console (but are not
     // exhaustive).
     switch (result) {
-    case Network::GetAddrInfoError::SUCCESS:
+    case GetAddrInfoError::SUCCESS:
         return NetDbError::Success;
-    case Network::GetAddrInfoError::AGAIN:
+    case GetAddrInfoError::AGAIN:
         return NetDbError::TryAgain;
-    case Network::GetAddrInfoError::NODATA:
+    case GetAddrInfoError::NODATA:
         return NetDbError::HostNotFound;
-    case Network::GetAddrInfoError::SERVICE:
+    case GetAddrInfoError::SERVICE:
         return NetDbError::Success;
     default:
         return NetDbError::HostNotFound;
     }
 }
 
-static Network::Errno GetAddrInfoErrorToErrno(Network::GetAddrInfoError result) {
+static Errno GetAddrInfoErrorToErrno(GetAddrInfoError result) {
     // These combinations have been verified on console (but are not
     // exhaustive).
     switch (result) {
-    case Network::GetAddrInfoError::SUCCESS:
+    case GetAddrInfoError::SUCCESS:
         // Note: Sometimes a successful lookup sets errno to EADDRNOTAVAIL for
         // some reason, but that doesn't seem useful to implement.
-        return Network::Errno::SUCCESS;
-    case Network::GetAddrInfoError::AGAIN:
-        return Network::Errno::SUCCESS;
-    case Network::GetAddrInfoError::NODATA:
-        return Network::Errno::SUCCESS;
-    case Network::GetAddrInfoError::SERVICE:
-        return Network::Errno::INVAL;
+        return Errno::SUCCESS;
+    case GetAddrInfoError::AGAIN:
+        return Errno::SUCCESS;
+    case GetAddrInfoError::NODATA:
+        return Errno::SUCCESS;
+    case GetAddrInfoError::SERVICE:
+        return Errno::INVAL;
     default:
-        return Network::Errno::SUCCESS;
+        return Errno::SUCCESS;
     }
 }
 
@@ -155,7 +155,9 @@ 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(std::span<const Network::AddrInfo> vec, std::string_view host) {
+static std::vector<u8> SerializeAddrInfoAsHostEnt(const std::vector<Network::AddrInfo>& vec,
+                                                  std::string_view host) {
+
     std::vector<u8> data;
     // h_name: use the input hostname (append nul-terminated)
     AppendNulTerminated(data, host);
@@ -163,12 +165,12 @@ static std::vector<u8> SerializeAddrInfoAsHostEnt(std::span<const Network::AddrI
 
     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, u16(Network::Domain::INET)); // h_addrtype
+    Append<u16_be>(data, static_cast<u16>(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, u32(count));
+    Append<u32_be>(data, static_cast<uint32_t>(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.
@@ -180,7 +182,7 @@ static std::vector<u8> SerializeAddrInfoAsHostEnt(std::span<const Network::AddrI
     return data;
 }
 
-static std::pair<u32, Network::GetAddrInfoError> GetHostByNameRequestImpl(HLERequestContext& ctx) {
+static std::pair<u32, GetAddrInfoError> GetHostByNameRequestImpl(HLERequestContext& ctx) {
     struct InputParameters {
         u8 use_nsd_resolve;
         u32 cancel_handle;
@@ -203,7 +205,7 @@ static std::pair<u32, Network::GetAddrInfoError> GetHostByNameRequestImpl(HLEReq
     // Prevent resolution of Nintendo servers
     if (IsBlockedHost(host)) {
         LOG_WARNING(Network, "Resolution of hostname {} requested, returning EAI_AGAIN", host);
-        return {0, Network::GetAddrInfoError::AGAIN};
+        return {0, GetAddrInfoError::AGAIN};
     }
 
     auto res_v = Network::GetAddressInfo(host, /*service*/ std::nullopt);
@@ -211,10 +213,10 @@ static std::pair<u32, Network::GetAddrInfoError> GetHostByNameRequestImpl(HLEReq
         const std::vector<u8> data = SerializeAddrInfoAsHostEnt(*res, host);
         const u32 data_size = u32(data.size());
         ctx.WriteBuffer(data, 0);
-        return {data_size, Network::GetAddrInfoError::SUCCESS};
+        return {data_size, GetAddrInfoError::SUCCESS};
     }
     auto* err = std::get_if<Network::GetAddrInfoError>(&res_v);
-    return {0, *err};
+    return {0, Translate(*err)};
 }
 
 void SFDNSRES::GetHostByNameRequest(HLERequestContext& ctx) {
@@ -222,7 +224,7 @@ void SFDNSRES::GetHostByNameRequest(HLERequestContext& ctx) {
 
     struct OutputParameters {
         NetDbError netdb_error;
-        Network::Errno bsd_errno;
+        Errno bsd_errno;
         u32 data_size;
     };
     static_assert(sizeof(OutputParameters) == 0xc);
@@ -242,7 +244,7 @@ void SFDNSRES::GetHostByNameRequestWithOptions(HLERequestContext& ctx) {
     struct OutputParameters {
         u32 data_size;
         NetDbError netdb_error;
-        Network::Errno bsd_errno;
+        Errno bsd_errno;
     };
     static_assert(sizeof(OutputParameters) == 0xc);
 
@@ -255,23 +257,24 @@ void SFDNSRES::GetHostByNameRequestWithOptions(HLERequestContext& ctx) {
     });
 }
 
-static std::vector<u8> SerializeAddrInfo(std::span<const Network::AddrInfo> vec, std::string_view host) {
+static std::vector<u8> SerializeAddrInfo(const std::vector<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, 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, 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, 16); // ai_addrlen
         // ^ *not* sizeof(SerializedSockAddrIn), not that it matters since they're the same size
 
         // ai_addr:
-        Append<u16_be>(data, u16(addrinfo.addr.family)); // sin_family
+        Append<u16_be>(data, static_cast<u16>(Translate(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
@@ -293,7 +296,7 @@ static std::vector<u8> SerializeAddrInfo(std::span<const Network::AddrInfo> vec,
     return data;
 }
 
-static std::pair<u32, Network::GetAddrInfoError> GetAddrInfoRequestImpl(HLERequestContext& ctx) {
+static std::pair<u32, GetAddrInfoError> GetAddrInfoRequestImpl(HLERequestContext& ctx) {
     struct InputParameters {
         u8 use_nsd_resolve;
         u32 cancel_handle;
@@ -318,7 +321,7 @@ static std::pair<u32, Network::GetAddrInfoError> GetAddrInfoRequestImpl(HLEReque
     // Prevent resolution of Nintendo servers
     if (IsBlockedHost(host)) {
         LOG_WARNING(Network, "Resolution of hostname {} requested, returning EAI_AGAIN", host);
-        return {0, Network::GetAddrInfoError::AGAIN};
+        return {0, GetAddrInfoError::AGAIN};
     }
 
     std::optional<std::string> service = std::nullopt;
@@ -328,23 +331,24 @@ static std::pair<u32, Network::GetAddrInfoError> GetAddrInfoRequestImpl(HLEReque
     }
 
     // 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, Network::GetAddrInfoError::SUCCESS};
+        return {data_size, GetAddrInfoError::SUCCESS};
     }
     auto* err = std::get_if<Network::GetAddrInfoError>(&res_v);
-    return {0, *err};
+    return {0, Translate(*err)};
 }
 
 void SFDNSRES::GetAddrInfoRequest(HLERequestContext& ctx) {
     auto [data_size, emu_gai_err] = GetAddrInfoRequestImpl(ctx);
 
     struct OutputParameters {
-        Network::Errno bsd_errno;
-        Network::GetAddrInfoError gai_error;
+        Errno bsd_errno;
+        GetAddrInfoError gai_error;
         u32 data_size;
     };
     static_assert(sizeof(OutputParameters) == 0xc);
@@ -360,7 +364,7 @@ void SFDNSRES::GetAddrInfoRequest(HLERequestContext& ctx) {
 
 void SFDNSRES::GetGaiStringErrorRequest(HLERequestContext& ctx) {
     struct InputParameters {
-        Network::GetAddrInfoError gai_errno;
+        GetAddrInfoError gai_errno;
     };
     IPC::RequestParser rp{ctx};
     auto input = rp.PopRaw<InputParameters>();
@@ -378,9 +382,9 @@ void SFDNSRES::GetAddrInfoRequestWithOptions(HLERequestContext& ctx) {
 
     struct OutputParameters {
         u32 data_size;
-        Network::GetAddrInfoError gai_error;
+        GetAddrInfoError gai_error;
         NetDbError netdb_error;
-        Network::Errno bsd_errno;
+        Errno bsd_errno;
     };
     static_assert(sizeof(OutputParameters) == 0x10);
 

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

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -21,6 +18,7 @@ void LoopProcess(Core::System& system) {
     server_manager->RegisterNamedService("nsd:a", std::make_shared<NSD>(system, "nsd:a"));
     server_manager->RegisterNamedService("nsd:u", std::make_shared<NSD>(system, "nsd:u"));
     server_manager->RegisterNamedService("sfdnsres", std::make_shared<SFDNSRES>(system));
+    server_manager->StartAdditionalHostThreads("bsdsocket", 2);
     ServerManager::RunServer(std::move(server_manager));
 }
 

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

@@ -8,7 +8,6 @@
 
 #include "common/common_funcs.h"
 #include "common/common_types.h"
-#include "core/internal_network/socket_types.h"
 
 namespace Core {
 class System;
@@ -16,6 +15,242 @@ 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,42 +15,388 @@
 
 namespace Service::Sockets {
 
-const char* Translate(Network::GetAddrInfoError error) {
-    // https://android.googlesource.com/platform/bionic/+/085543106/libc/dns/net/getaddrinfo.c#254
+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 "Success";
+        return GetAddrInfoError::SUCCESS;
     case Network::GetAddrInfoError::ADDRFAMILY:
-        return "Address family for hostname not supported";
+        return GetAddrInfoError::ADDRFAMILY;
     case Network::GetAddrInfoError::AGAIN:
-        return "Temporary failure in name resolution";
+        return GetAddrInfoError::AGAIN;
     case Network::GetAddrInfoError::BADFLAGS:
-        return "Invalid value for ai_flags";
+        return GetAddrInfoError::BADFLAGS;
     case Network::GetAddrInfoError::FAIL:
-        return "Non-recoverable failure in name resolution";
+        return GetAddrInfoError::FAIL;
     case Network::GetAddrInfoError::FAMILY:
-        return "ai_family not supported";
+        return GetAddrInfoError::FAMILY;
     case Network::GetAddrInfoError::MEMORY:
-        return "Memory allocation failure";
+        return GetAddrInfoError::MEMORY;
     case Network::GetAddrInfoError::NODATA:
-        return "No address associated with hostname";
+        return GetAddrInfoError::NODATA;
     case Network::GetAddrInfoError::NONAME:
-        return "hostname nor servname provided, or not known";
+        return GetAddrInfoError::NONAME;
     case Network::GetAddrInfoError::SERVICE:
-        return "servname not supported for ai_socktype";
+        return GetAddrInfoError::SERVICE;
     case Network::GetAddrInfoError::SOCKTYPE:
-        return "ai_socktype not supported";
+        return GetAddrInfoError::SOCKTYPE;
     case Network::GetAddrInfoError::SYSTEM:
-        return "System error returned in errno";
+        return GetAddrInfoError::SYSTEM;
     case Network::GetAddrInfoError::BADHINTS:
-        return "Invalid value for hints";
+        return GetAddrInfoError::BADHINTS;
     case Network::GetAddrInfoError::PROTOCOL:
-        return "Resolved protocol is unknown";
+        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) {
+    // https://android.googlesource.com/platform/bionic/+/085543106/libc/dns/net/getaddrinfo.c#254
+    switch (error) {
+    case GetAddrInfoError::SUCCESS:
+        return "Success";
+    case GetAddrInfoError::ADDRFAMILY:
+        return "Address family for hostname not supported";
+    case GetAddrInfoError::AGAIN:
+        return "Temporary failure in name resolution";
+    case GetAddrInfoError::BADFLAGS:
+        return "Invalid value for ai_flags";
+    case GetAddrInfoError::FAIL:
+        return "Non-recoverable failure in name resolution";
+    case GetAddrInfoError::FAMILY:
+        return "ai_family not supported";
+    case GetAddrInfoError::MEMORY:
+        return "Memory allocation failure";
+    case GetAddrInfoError::NODATA:
+        return "No address associated with hostname";
+    case GetAddrInfoError::NONAME:
+        return "hostname nor servname provided, or not known";
+    case GetAddrInfoError::SERVICE:
+        return "servname not supported for ai_socktype";
+    case GetAddrInfoError::SOCKTYPE:
+        return "ai_socktype not supported";
+    case GetAddrInfoError::SYSTEM:
+        return "System error returned in errno";
+    case GetAddrInfoError::BADHINTS:
+        return "Invalid value for hints";
+    case GetAddrInfoError::PROTOCOL:
+        return "Resolved protocol is unknown";
+    case 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,6 +1,3 @@
-// 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
 
@@ -14,7 +11,49 @@
 
 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(Network::GetAddrInfoError value);
+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);
 
 } // namespace Service::Sockets

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

@@ -132,7 +132,7 @@ public:
                 auto bsd = system.ServiceManager().GetService<Service::Sockets::BSD>("bsd:u");
                 if (bsd) {
                     auto err = bsd->CloseImpl(fd);
-                    if (err != Network::Errno::SUCCESS) {
+                    if (err != Service::Sockets::Errno::SUCCESS) {
                         LOG_ERROR(Service_SSL, "Failed to close duplicated socket: {}", err);
                     }
                 }

src/core/internal_network/emu_net_state.h

@@ -1,11 +1,10 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 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 "core/internal_network/socket_types.h"
+#include "common/socket_types.h"
 
 #ifdef _WIN32
 #include <winsock2.h>
@@ -31,10 +31,68 @@ namespace Network {
 class SocketBase;
 class Socket;
 
-struct HostPollFD {
-    SocketBase* socket = nullptr;
-    Network::PollEvents events = {};
-    Network::PollEvents revents = {};
+/// 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;
 };
 
 class NetworkInstance {

src/core/internal_network/network_interface.cpp

@@ -46,7 +46,7 @@ namespace Network {
 
 #ifdef _WIN32
 
-std::vector<NetworkInterface> GetAvailableNetworkInterfaces() {
+std::vector<Network::NetworkInterface> GetAvailableNetworkInterfaces() {
 
     ULONG buf_size = 0;
     if (GetAdaptersAddresses(
@@ -66,7 +66,7 @@ std::vector<NetworkInterface> GetAvailableNetworkInterfaces() {
         return {};
     }
 
-    std::vector<NetworkInterface> result;
+    std::vector<Network::NetworkInterface> result;
 
     for (auto* a = addrs; a; a = a->Next) {
 
@@ -89,7 +89,7 @@ std::vector<NetworkInterface> GetAvailableNetworkInterfaces() {
             gw = reinterpret_cast<sockaddr_in*>(a->FirstGatewayAddress->Address.lpSockaddr)
                      ->sin_addr;
 
-        result.emplace_back(NetworkInterface{
+        result.emplace_back(Network::NetworkInterface{
             .name = Common::UTF16ToUTF8(std::wstring{a->FriendlyName}),
             .ip_address = ip,
             .subnet_mask = mask,
@@ -103,7 +103,7 @@ std::vector<NetworkInterface> GetAvailableNetworkInterfaces() {
 
 #else
 
-std::vector<NetworkInterface> GetAvailableNetworkInterfaces() {
+std::vector<Network::NetworkInterface> GetAvailableNetworkInterfaces() {
 #if defined(__ANDROID__) || defined(__linux__)
     struct ifaddrs* ifaddr = nullptr;
     if (getifaddrs(&ifaddr) != 0) {
@@ -135,7 +135,7 @@ std::vector<NetworkInterface> GetAvailableNetworkInterfaces() {
         LOG_WARNING(Network, "\"/proc/net/route\" not found - using gateway 0");
     }
 #endif
-    std::vector<NetworkInterface> ifaces;
+    std::vector<Network::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<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(NetworkInterface{
+        ifaces.emplace_back(Network::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<NetworkInterface> GetAvailableNetworkInterfaces() {
     freeifaddrs(ifaddr);
     return ifaces;
 #elif defined(__FreeBSD__)
-    std::vector<NetworkInterface> ifaces;
+    std::vector<Network::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<NetworkInterface> GetAvailableNetworkInterfaces() {
             size_t msglen = rtm->rtm_msglen - sizeof(*ifm);
             char const* p = (char const*)(ifm + 1);
 
-            NetworkInterface iface{};
+            Network::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<NetworkInterface> GetAvailableNetworkInterfaces() {
 
 #endif // _WIN32
 
-std::optional<NetworkInterface> GetSelectedNetworkInterface() {
+std::optional<Network::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_proxy.cpp

@@ -47,82 +47,71 @@ void ProxySocket::HandleProxyPacket(const ProxyPacket& packet) {
     received_packets.push(decompressed);
 }
 
-Errno ProxySocket::SetNonBlock(bool enable) {
-    blocking = !enable;
-    return Errno::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;
-    }
+template <typename T>
+Errno ProxySocket::SetSockOpt(SOCKET fd_, int option, T value) {
+    LOG_DEBUG(Network, "(STUBBED) called");
     return Errno::SUCCESS;
 }
 
 Errno ProxySocket::Initialize(Domain domain, Type type, Protocol socket_protocol) {
     protocol = socket_protocol;
+    SetSockOpt(fd, SO_TYPE, type);
+
     return Errno::SUCCESS;
 }
 
 std::pair<ProxySocket::AcceptResult, Errno> ProxySocket::Accept() {
-    LOG_WARNING(Network, "(stubbed) called");
+    LOG_WARNING(Network, "(STUBBED) called");
     return {AcceptResult{}, Errno::SUCCESS};
 }
 
-Errno ProxySocket::Connect(Network::SockAddrIn addr_in) {
-    LOG_WARNING(Network, "(stubbed) called");
+Errno ProxySocket::Connect(SockAddrIn addr_in) {
+    LOG_WARNING(Network, "(STUBBED) called");
     return Errno::SUCCESS;
 }
 
-std::pair<Network::SockAddrIn, Errno> ProxySocket::GetPeerName() {
-    LOG_WARNING(Network, "(stubbed) called");
-    return {Network::SockAddrIn{}, Errno::SUCCESS};
+std::pair<SockAddrIn, Errno> ProxySocket::GetPeerName() {
+    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::SUCCESS};
+std::pair<SockAddrIn, Errno> ProxySocket::GetSockName() {
+    LOG_WARNING(Network, "(STUBBED) called");
+    return {SockAddrIn{}, Errno::SUCCESS};
 }
 
-Errno ProxySocket::Bind(Network::SockAddrIn addr) {
+Errno ProxySocket::Bind(SockAddrIn addr) {
     if (is_bound) {
         LOG_WARNING(Network, "Rebinding Socket is unimplemented!");
         return Errno::SUCCESS;
     }
     local_endpoint = addr;
     is_bound = true;
+
     return Errno::SUCCESS;
 }
 
 Errno ProxySocket::Listen(s32 backlog) {
-    LOG_WARNING(Network, "(stubbed) called");
+    LOG_WARNING(Network, "(STUBBED) called");
     return Errno::SUCCESS;
 }
 
 Errno ProxySocket::Shutdown(ShutdownHow how) {
-    LOG_WARNING(Network, "(stubbed) called");
+    LOG_WARNING(Network, "(STUBBED) called");
     return Errno::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() < std::size_t((std::numeric_limits<int>::max)()));
-    return {s32(0), Errno::SUCCESS};
+    ASSERT(message.size() < static_cast<size_t>((std::numeric_limits<int>::max)()));
+
+    return {static_cast<s32>(0), Errno::SUCCESS};
 }
 
-std::pair<s32, Errno> ProxySocket::RecvFrom(int flags, std::span<u8> message, Network::SockAddrIn* addr) {
+std::pair<s32, Errno> ProxySocket::RecvFrom(int flags, std::span<u8> message, SockAddrIn* addr) {
     ASSERT(flags == 0);
-    ASSERT(message.size() < std::size_t((std::numeric_limits<int>::max)()));
+    ASSERT(message.size() < static_cast<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();
@@ -145,29 +134,29 @@ std::pair<s32, Errno> ProxySocket::RecvFrom(int flags, std::span<u8> message, Ne
         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};
         }
     }
 }
 
-std::pair<s32, Errno> ProxySocket::ReceivePacket(int flags, std::span<u8> message, Network::SockAddrIn* addr, std::size_t max_length) {
-    LOG_DEBUG(Network, "called");
+std::pair<s32, Errno> ProxySocket::ReceivePacket(int flags, std::span<u8> message, SockAddrIn* addr,
+                                                 std::size_t max_length) {
     ProxyPacket& packet = received_packets.front();
     if (addr) {
-        addr->len = 16;
-        addr->family = u8(Network::Domain::INET);
+        addr->family = 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 & u32(Network::MsgOpt::PEEK)) != 0;
+    bool peek = (flags & FLAG_MSG_PEEK) != 0;
     std::size_t read_bytes;
     if (packet.data.size() > max_length) {
         read_bytes = max_length;
-        std::memcpy(message.data(), packet.data.data(), max_length);
+        memcpy(message.data(), packet.data.data(), max_length);
 
         if (protocol == Protocol::UDP) {
             if (!peek) {
@@ -176,48 +165,51 @@ std::pair<s32, Errno> ProxySocket::ReceivePacket(int flags, std::span<u8> messag
             return {-1, Errno::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();
-        std::memcpy(message.data(), packet.data.data(), read_bytes);
+        memcpy(message.data(), packet.data.data(), read_bytes);
         if (!peek) {
             received_packets.pop();
         }
     }
 
-    return {u32(read_bytes), Errno::SUCCESS};
+    return {static_cast<u32>(read_bytes), Errno::SUCCESS};
 }
 
 std::pair<s32, Errno> ProxySocket::Send(std::span<const u8> message, int flags) {
-    LOG_WARNING(Network, "(stubbed) called");
-    ASSERT(message.size() < size_t((std::numeric_limits<int>::max)()));
+    LOG_WARNING(Network, "(STUBBED) called");
+    ASSERT(message.size() < static_cast<size_t>((std::numeric_limits<int>::max)()));
     ASSERT(flags == 0);
-    return {s32(0), Errno::SUCCESS};
+
+    return {static_cast<s32>(0), Errno::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 Network::SockAddrIn* addr) {
-    LOG_DEBUG(Network, "called");
+std::pair<s32, Errno> ProxySocket::SendTo(u32 flags, std::span<const u8> message,
+                                          const SockAddrIn* addr) {
     ASSERT(flags == 0);
 
     if (!is_bound) {
         LOG_ERROR(Network, "ProxySocket is not bound!");
-        return {s32(message.size()), Errno::SUCCESS};
+        return {static_cast<s32>(message.size()), Errno::SUCCESS};
     }
 
     if (auto room_member = Network::GetRoomMember().lock()) {
         if (!room_member->IsConnected()) {
-            return {s32(message.size()), Errno::SUCCESS};
+            return {static_cast<s32>(message.size()), Errno::SUCCESS};
         }
     }
 
@@ -242,19 +234,65 @@ std::pair<s32, Errno> ProxySocket::SendTo(u32 flags, std::span<const u8> message
 
     SendPacket(packet);
 
-    return {s32(message.size()), Errno::SUCCESS};
+    return {static_cast<s32>(message.size()), Errno::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;
+}
+
 std::pair<Errno, Errno> ProxySocket::GetPendingError() {
-    LOG_DEBUG(Network, "called");
+    LOG_DEBUG(Network, "(STUBBED) called");
     return {Errno::SUCCESS, Errno::SUCCESS};
 }
 

src/core/internal_network/socket_proxy.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 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(Network::SockAddrIn addr_in) override;
+    Errno Connect(SockAddrIn addr_in) override;
 
-    std::pair<Network::SockAddrIn, Errno> GetPeerName() override;
+    std::pair<SockAddrIn, Errno> GetPeerName() override;
 
-    std::pair<Network::SockAddrIn, Errno> GetSockName() override;
+    std::pair<SockAddrIn, Errno> GetSockName() override;
 
-    Errno Bind(Network::SockAddrIn addr) override;
+    Errno Bind(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, Network::SockAddrIn* addr) override;
+    std::pair<s32, Errno> RecvFrom(int flags, std::span<u8> message, SockAddrIn* addr) override;
 
-    std::pair<s32, Errno> ReceivePacket(int flags, std::span<u8> message, Network::SockAddrIn* addr,
+    std::pair<s32, Errno> ReceivePacket(int flags, std::span<u8> message, SockAddrIn* addr,
                                         std::size_t max_length);
 
     std::pair<s32, Errno> Send(std::span<const u8> message, int flags) override;
@@ -53,11 +53,28 @@ public:
     void SendPacket(ProxyPacket& packet);
 
     std::pair<s32, Errno> SendTo(u32 flags, std::span<const u8> message,
-                                 const Network::SockAddrIn* addr) override;
+                                 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;
 
     Errno SetNonBlock(bool enable) override;
 
-    Errno SetSockOpt(Network::SocketLevel level, Network::OptName option, std::span<const u8> value) override;
+    template <typename T>
+    Errno SetSockOpt(SOCKET fd, int option, T value);
 
     std::pair<Errno, Errno> GetPendingError() override;
 
@@ -69,7 +86,7 @@ private:
     u32 send_timeout = 0;
     u32 receive_timeout = 0;
     bool is_bound = false;
-    Network::SockAddrIn local_endpoint{};
+    SockAddrIn local_endpoint{};
     bool blocking = true;
     std::queue<ProxyPacket> received_packets;
     Protocol protocol;

src/core/internal_network/socket_types.h

@@ -1,360 +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"
-#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 {
-    SUCCESS = 0,
-    BADF = 9,
-    AGAIN = 11,
-    INVAL = 22,
-    MFILE = 24,
-    PIPE = 32,
-    NOTSOCK = 88,
-    MSGSIZE = 90,
-    PROTOTYPE = 91,
-    NOPROTOOPT = 92,
-    PROTONOSUPPORT = 93,
-    SOCKTNOSUPPORT = 94,
-    NOTSUP = 95,
-    ADDRINUSE = 98,
-    ADDRNOTAVAIL = 99,
-    NETDOWN = 100,
-    NETUNREACH = 101,
-    CONNABORTED = 103,
-    CONNRESET = 104,
-    ISCONN = 106,
-    NOTCONN = 107,
-    TIMEDOUT = 110,
-    CONNREFUSED = 111,
-    HOSTUNREACH = 113,
-    ALREADY = 114,
-    INPROGRESS = 115,
-    STALE = 116,
-    /* made up error? */
-    OTHER = 196,
-};
-
-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);
-
-/// @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 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 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;
-        Network::SockAddrIn sockaddr_in;
+        SockAddrIn sockaddr_in;
     };
 
     SocketBase() = default;
@@ -46,13 +46,13 @@ public:
 
     virtual std::pair<AcceptResult, Errno> Accept() = 0;
 
-    virtual Errno Connect(Network::SockAddrIn addr_in) = 0;
+    virtual Errno Connect(SockAddrIn addr_in) = 0;
 
-    virtual std::pair<Network::SockAddrIn, Errno> GetPeerName() = 0;
+    virtual std::pair<SockAddrIn, Errno> GetPeerName() = 0;
 
-    virtual std::pair<Network::SockAddrIn, Errno> GetSockName() = 0;
+    virtual std::pair<SockAddrIn, Errno> GetSockName() = 0;
 
-    virtual Errno Bind(Network::SockAddrIn addr) = 0;
+    virtual Errno Bind(SockAddrIn addr) = 0;
 
     virtual Errno Listen(s32 backlog) = 0;
 
@@ -60,16 +60,31 @@ 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, Network::SockAddrIn* addr) = 0;
+    virtual std::pair<s32, Errno> RecvFrom(int flags, std::span<u8> message, 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 Network::SockAddrIn* addr) = 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 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;
@@ -80,6 +95,7 @@ public:
         return fd;
     }
 
+protected:
     SOCKET fd = INVALID_SOCKET;
 };
 
@@ -98,13 +114,13 @@ public:
 
     std::pair<AcceptResult, Errno> Accept() override;
 
-    Errno Connect(Network::SockAddrIn addr_in) override;
+    Errno Connect(SockAddrIn addr_in) override;
 
-    std::pair<Network::SockAddrIn, Errno> GetPeerName() override;
+    std::pair<SockAddrIn, Errno> GetPeerName() override;
 
-    std::pair<Network::SockAddrIn, Errno> GetSockName() override;
+    std::pair<SockAddrIn, Errno> GetSockName() override;
 
-    Errno Bind(Network::SockAddrIn addr) override;
+    Errno Bind(SockAddrIn addr) override;
 
     Errno Listen(s32 backlog) override;
 
@@ -112,19 +128,38 @@ public:
 
     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> RecvFrom(int flags, std::span<u8> message, 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;
+    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;
 
     Errno SetNonBlock(bool enable) override;
 
-    Errno SetSockOpt(Network::SocketLevel level, Network::OptName option, std::span<const u8> value) override;
+    template <typename T>
+    Errno SetSockOpt(SOCKET fd, int option, T value);
 
     std::pair<Errno, Errno> GetPendingError() override;
 
-    Errno GetSockOpt(Network::SocketLevel level, Network::OptName optname, std::span<u8> value);
+    template <typename T>
+    std::pair<T, Errno> GetSockOpt(SOCKET fd, int option);
 
     bool IsOpened() const override;
 
@@ -134,6 +169,6 @@ private:
     bool is_non_blocking = false;
 };
 
-std::pair<s32, Errno> Poll(std::span<Network::HostPollFD> poll_fds, s32 timeout);
+std::pair<s32, Errno> Poll(std::vector<PollFD>& poll_fds, s32 timeout);
 
 } // namespace Network

src/dynarmic/CMakeLists.txt

@@ -25,7 +25,7 @@ endif()
 # Dynarmic project options
 option(DYNARMIC_ENABLE_CPU_FEATURE_DETECTION "Turning this off causes dynarmic to assume the host CPU doesn't support anything later than SSE3" ON)
 
-if (PLATFORM_OPENBSD OR PLATFORM_DRAGONFLY OR PLATFORM_NETBSD)
+if (OPENBSD OR DRAGONFLY OR NETBSD)
     set(REQUIRE_WX ON)
 else()
     set(REQUIRE_WX OFF)

src/dynarmic/src/dynarmic/CMakeLists.txt

@@ -363,7 +363,7 @@ elseif (APPLE)
             backend/exception_handler_macos_mig.c
         )
     endif()
-elseif (UNIX AND NOT PLATFORM_HAIKU)
+elseif (UNIX AND NOT HAIKUOS)
     # Haiku lacks <ucontext.h>
     if (CMAKE_SYSTEM_NAME STREQUAL "Linux")
         target_link_libraries(dynarmic PRIVATE rt)

src/network/CMakeLists.txt

@@ -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: 2022 yuzu Emulator Project
@@ -28,6 +28,6 @@ if (ENABLE_WEB_SERVICE)
 endif()
 
 # Solaris uses /lib/amd64/libsocket.so and /lib/amd64/libnsl.so
-if (PLATFORM_SUN)
+if (SOLARIS)
     target_link_libraries(network PRIVATE socket nsl)
 endif()

src/network/room.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 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 "core/internal_network/socket_types.h"
+#include "common/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 "core/internal_network/socket_types.h"
+#include "common/socket_types.h"
 #include "enet/enet.h"
 #include "network/packet.h"
 #include "network/room_member.h"
@@ -358,23 +358,19 @@ void RoomMember::RoomMemberImpl::HandleProxyPackets(const ENetEvent* event) {
     // Parse the ProxyPacket from the packet
     u8 local_family;
     packet.Read(local_family);
-    proxy_packet.local_endpoint.len = 16;
-    proxy_packet.local_endpoint.family = u8(Network::Domain(local_family));
+    proxy_packet.local_endpoint.family = static_cast<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.len = 16;
-    proxy_packet.remote_endpoint.family = u8(Network::Domain(remote_family));
+    proxy_packet.remote_endpoint.family = static_cast<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 = Network::Protocol(protocol_type);
+    proxy_packet.protocol = static_cast<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 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 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 "core/internal_network/socket_types.h"
+#include "common/socket_types.h"
 #include "network/room.h"
 
 namespace Network {
@@ -39,8 +39,8 @@ struct LDNPacket {
 
 /// Information about the received proxy packets.
 struct ProxyPacket {
-    Network::SockAddrIn local_endpoint;
-    Network::SockAddrIn remote_endpoint;
+    SockAddrIn local_endpoint;
+    SockAddrIn remote_endpoint;
     Protocol protocol;
     bool broadcast;
     std::vector<u8> data;

src/tests/core/internal_network/network.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
 
@@ -19,11 +16,9 @@ TEST_CASE("Network::Errors", "[core]") {
     }
 
     Network::SockAddrIn addr{
-        16,
-        u8(Network::Domain::INET),
-        1, // hopefully nobody running this test has something listening on port 1
+        Network::Domain::INET,
         {127, 0, 0, 1},
-        {},
+        1, // hopefully nobody running this test has something listening on port 1
     };
     REQUIRE(socks[0].Connect(addr) == Network::Errno::CONNREFUSED);
 

src/video_core/host_shaders/CMakeLists.txt

@@ -88,7 +88,7 @@ set(SHADER_FILES
     ${CMAKE_CURRENT_SOURCE_DIR}/sgsr1_shader_mobile_edge_direction.frag
 )
 
-if (PLATFORM_HAIKU)
+if (HAIKUOS)
     # glslangValidator WILL crash, glslang will not
     set(GLSLANGVALIDATOR "glslang")
 else()

src/yuzu/CMakeLists.txt

@@ -8,7 +8,7 @@ set(CMAKE_INCLUDE_CURRENT_DIR ON)
 
 # Set the RPATH for Qt Libraries
 # This must be done before the `yuzu` target is created
-if (YUZU_USE_BUNDLED_QT AND PLATFORM_LINUX)
+if (YUZU_USE_BUNDLED_QT AND LINUX)
     set(CMAKE_BUILD_RPATH "${CMAKE_BINARY_DIR}/bin/lib/")
 endif()
 

src/yuzu/main.cpp

@@ -16,6 +16,12 @@
 #include <sys/resource.h>
 #endif
 
+#if defined(__APPLE__)
+#include <climits>
+#include <cstdlib>
+#include <cstring>
+#endif
+
 #include "main_window.h"
 
 #ifdef _WIN32
@@ -126,6 +132,16 @@ int main(int argc, char* argv[]) {
 #endif // _WIN32
 
 #if defined(__APPLE__)
+    // Convert the relative path to an absolute path before the chdir
+    char resolved[PATH_MAX];
+    for (int i = 1; i < argc; ++i) {
+        if (strcmp(argv[i], "-u") == 0 || strcmp(argv[i], "-input-profile") == 0) {
+            ++i;
+        } else if (argv[i][0] != '-' && argv[i][0] != '/' && realpath(argv[i], resolved)) {
+            argv[i] = strdup(resolved);
+        }
+    }
+
     // If you start a bundle (binary) on OSX without the Terminal, the working directory is "/".
     // But since we require the working directory to be the executable path for the location of
     // the user folder in the Qt Frontend, we need to cd into that working directory

src/yuzu_cmd/emu_window/emu_window_sdl3.cpp

@@ -5,6 +5,10 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include <SDL3/SDL.h>
+#include <SDL3/SDL_timer.h>
+#ifdef __EMSCRIPTEN__
+#include <emscripten.h>
+#endif
 
 #include "common/logging.h"
 #include "common/scm_rev.h"
@@ -26,9 +30,17 @@ EmuWindow_SDL3::EmuWindow_SDL3(InputCommon::InputSubsystem* input_subsystem_, Co
         LOG_CRITICAL(Frontend, "Failed to initialize SDL3: {}, Exiting...", SDL_GetError());
         exit(1);
     }
+    titlebar_timer = SDL_AddTimer(2000, [](void *userdata, SDL_TimerID, Uint32) -> Uint32 {
+        auto* this_ = (EmuWindow_SDL3*)userdata;
+        auto const results = this_->system.GetAndResetPerfStats();
+        auto const title = fmt::format("{} | {}-{} | FPS: {:.0f} ({:.0f}%)", Common::g_build_fullname, Common::g_scm_branch, Common::g_scm_desc, results.average_game_fps, results.emulation_speed * 100.0f);
+        SDL_SetWindowTitle(this_->render_window, title.c_str());
+        return 2000;
+    }, this);
 }
 
 EmuWindow_SDL3::~EmuWindow_SDL3() {
+    SDL_RemoveTimer(titlebar_timer);
     system.HIDCore().UnloadInputDevices();
     input_subsystem->Shutdown();
     SDL_Quit();
@@ -132,8 +144,7 @@ void EmuWindow_SDL3::Fullscreen() {
     switch (Settings::values.fullscreen_mode.GetValue()) {
     case Settings::FullscreenMode::Exclusive:
         // Set window size to render size before entering fullscreen in exclusive mode.
-        if (const SDL_DisplayMode* display_mode_ptr =
-                SDL_GetDesktopDisplayMode(SDL_GetDisplayForWindow(render_window))) {
+        if (const SDL_DisplayMode* display_mode_ptr = SDL_GetDesktopDisplayMode(SDL_GetDisplayForWindow(render_window))) {
             display_mode = *display_mode_ptr;
             SDL_SetWindowSize(render_window, display_mode.w, display_mode.h);
             SDL_SetWindowFullscreenMode(render_window, &display_mode);
@@ -165,92 +176,60 @@ void EmuWindow_SDL3::Fullscreen() {
     }
 }
 
-void EmuWindow_SDL3::WaitEvent() {
-    // Called on main thread
-    SDL_Event event;
-
-    if (!SDL_WaitEvent(&event)) {
-        const char* error = SDL_GetError();
-        if (!error || strcmp(error, "") == 0) {
-            // https://github.com/libsdl-org/SDL/issues/5780
-            // Sometimes SDL will return without actually having hit an error condition;
-            // just ignore it in this case.
-            return;
-        }
-
-        LOG_CRITICAL(Frontend, "SDL_WaitEvent failed: {}", error);
-        exit(1);
-    }
-
+void EmuWindow_SDL3::OnEvent(SDL_Event& event) {
+    // Notice how we skip the "update title" aspect on most events
+    // this is because some WMs do NOT like changing titles while resizing
+    // so let's just... not do that, thanks :)
+    // Afterall we don't really expect the user to pay attention to the titlebar
+    // while they're moving a lot of shit around...
     switch (event.type) {
     case SDL_EVENT_WINDOW_RESIZED:
     case SDL_EVENT_WINDOW_PIXEL_SIZE_CHANGED:
     case SDL_EVENT_WINDOW_MAXIMIZED:
     case SDL_EVENT_WINDOW_RESTORED:
-        OnResize();
-        break;
+        return OnResize();
     case SDL_EVENT_WINDOW_MINIMIZED:
         is_shown = false;
-        OnResize();
-        break;
+        return OnResize();
     case SDL_EVENT_WINDOW_EXPOSED:
         is_shown = true;
-        OnResize();
-        break;
+        return OnResize();
     case SDL_EVENT_WINDOW_CLOSE_REQUESTED:
         is_open = false;
-        break;
+        return;
     case SDL_EVENT_KEY_DOWN:
     case SDL_EVENT_KEY_UP:
-        OnKeyEvent(static_cast<int>(event.key.scancode), event.key.down ? 1 : 0);
-        break;
+        return OnKeyEvent(int(event.key.scancode), event.key.down ? 1 : 0);
     case SDL_EVENT_MOUSE_MOTION:
         // ignore if it came from touch
         if (event.button.which != SDL_TOUCH_MOUSEID)
             OnMouseMotion(event.motion.x, event.motion.y);
-        break;
+        return;
     case SDL_EVENT_MOUSE_BUTTON_DOWN:
     case SDL_EVENT_MOUSE_BUTTON_UP:
         // ignore if it came from touch
-        if (event.button.which != SDL_TOUCH_MOUSEID) {
-            OnMouseButton(event.button.button, event.button.down ? 1 : 0,
-                          static_cast<s32>(event.button.x), static_cast<s32>(event.button.y));
-        }
-        break;
+        if (event.button.which != SDL_TOUCH_MOUSEID)
+            OnMouseButton(event.button.button, event.button.down ? 1 : 0, s32(event.button.x), s32(event.button.y));
+        return;
     case SDL_EVENT_FINGER_DOWN:
-        OnFingerDown(event.tfinger.x, event.tfinger.y,
-                     static_cast<std::size_t>(event.tfinger.touchID));
-        break;
+        return OnFingerDown(event.tfinger.x, event.tfinger.y, std::size_t(event.tfinger.touchID));
     case SDL_EVENT_FINGER_MOTION:
-        OnFingerMotion(event.tfinger.x, event.tfinger.y,
-                       static_cast<std::size_t>(event.tfinger.touchID));
-        break;
+        return OnFingerMotion(event.tfinger.x, event.tfinger.y, std::size_t(event.tfinger.touchID));
     case SDL_EVENT_FINGER_UP:
-        OnFingerUp();
-        break;
+        return OnFingerUp();
     case SDL_EVENT_QUIT:
         is_open = false;
-        break;
+        return;
     default:
         break;
     }
-
-    const u32 current_time = SDL_GetTicks();
-    if (current_time > last_time + 2000) {
-        const auto results = system.GetAndResetPerfStats();
-        const auto title = fmt::format("{} | {}-{} | FPS: {:.0f} ({:.0f}%)",
-                                       Common::g_build_fullname,
-                                       Common::g_scm_branch,
-                                       Common::g_scm_desc,
-                                       results.average_game_fps,
-                                       results.emulation_speed * 100.0);
-        SDL_SetWindowTitle(render_window, title.c_str());
-        last_time = current_time;
-    }
 }
 
 // Credits to Samantas5855 and others for this function.
 void EmuWindow_SDL3::SetWindowIcon() {
+#if defined(__EMSCRIPTEN__) || defined(__wasi__)
+    // Icons do not work yet
+#else
     SDL_IOStream* const yuzu_icon_stream = SDL_IOFromConstMem((void*)yuzu_icon, yuzu_icon_size);
     if (yuzu_icon_stream == nullptr) {
         LOG_WARNING(Frontend, "Failed to create Eden icon stream.");
@@ -264,6 +243,7 @@ void EmuWindow_SDL3::SetWindowIcon() {
     // The icon is attached to the window pointer
     SDL_SetWindowIcon(render_window, window_icon);
     SDL_DestroySurface(window_icon);
+#endif
 }
 
 void EmuWindow_SDL3::OnMinimalClientAreaChangeRequest(std::pair<u32, u32> minimal_size) {

src/yuzu_cmd/emu_window/emu_window_sdl3.h

@@ -9,11 +9,12 @@
 #include <tuple>
 #include <utility>
 
+#include <SDL3/SDL.h>
+#include <SDL3/SDL_timer.h>
+
 #include "core/frontend/emu_window.h"
 #include "core/frontend/graphics_context.h"
 
-struct SDL_Window;
-
 namespace Core {
 class System;
 }
@@ -35,7 +36,7 @@ public:
     bool IsShown() const override;
 
     /// Wait for the next event on the main thread.
-    void WaitEvent();
+    void OnEvent(SDL_Event& event);
 
     // Sets the window icon from yuzu.bmp
     void SetWindowIcon();
@@ -80,6 +81,9 @@ protected:
     /// Called when a configuration change affects the minimal size of the window
     void OnMinimalClientAreaChangeRequest(std::pair<u32, u32> minimal_size) override;
 
+    /// Periodic changer of titlebar (independent of event loop)
+    SDL_TimerID titlebar_timer;
+
     /// Is the window still open?
     bool is_open = true;
 
@@ -89,9 +93,6 @@ protected:
     /// Internal SDL3 render window
     SDL_Window* render_window{};
 
-    /// Keeps track of how often to update the title bar during gameplay
-    u32 last_time = 0;
-
     /// Input subsystem to use with this window.
     InputCommon::InputSubsystem* input_subsystem;
 

src/yuzu_cmd/yuzu.cpp

@@ -8,6 +8,12 @@
 #include <memory>
 #include <regex>
 #include <string>
+#include "common/settings_enums.h"
+#ifdef __EMSCRIPTEN__
+#include <emscripten.h>
+#endif
+#define SDL_MAIN_USE_CALLBACKS 1
+#include <SDL3/SDL_main.h>
 
 #include <fmt/ostream.h>
 
@@ -39,9 +45,7 @@
 #ifdef _WIN32
 // windows.h needs to be included before shellapi.h
 #include <windows.h>
-
 #include <shellapi.h>
-
 #include "common/windows/timer_resolution.h"
 #endif
 
@@ -174,8 +178,14 @@ static void OnStatusMessageReceived(const Network::StatusMessageEntry& msg) {
         std::cout << std::endl << "* " << message << std::endl << std::endl;
 }
 
-/// Application entry point
-int main(int argc, char** argv) {
+struct SdlState {
+    Core::System system{};
+    std::unique_ptr<EmuWindow_SDL3> emu_window;
+};
+
+extern "C" SDL_AppResult SDL_AppInit(void **appstate, int argc, char **argv) {
+    SdlState* state = new SdlState();
+
 #ifdef _WIN32
     if (AttachConsole(ATTACH_PARENT_PROCESS)) {
         freopen("CONOUT$", "wb", stdout);
@@ -193,7 +203,7 @@ int main(int argc, char** argv) {
     auto argv_w = CommandLineToArgvW(GetCommandLineW(), &argc_w);
     if (argv_w == nullptr) {
         LOG_CRITICAL(Frontend, "Failed to get command line arguments");
-        return -1;
+        return SDL_APP_FAILURE;
     }
 #endif
     std::string filepath;
@@ -247,7 +257,7 @@ int main(int argc, char** argv) {
                 break;
             case 'h':
                 PrintHelp(argv[0]);
-                return 0;
+                return SDL_APP_FAILURE;
             case 'g':
                 filepath = std::string(optarg);
                 break;
@@ -264,7 +274,7 @@ int main(int argc, char** argv) {
                 if (!std::regex_match(str_arg, re)) {
                     std::cout << "Wrong format for option --multiplayer\n";
                     PrintHelp(argv[0]);
-                    return -1;
+                    return SDL_APP_FAILURE;
                 }
 
                 std::smatch match;
@@ -279,11 +289,11 @@ int main(int argc, char** argv) {
                 std::regex nickname_re("^[a-zA-Z0-9._\\- ]+$");
                 if (!std::regex_match(nickname, nickname_re)) {
                     LOG_ERROR(Frontend, "Nickname is not valid. Must be 4 to 20 alphanumeric characters");
-                    return -1;
+                    return SDL_APP_FAILURE;
                 }
                 if (address.empty()) {
                     LOG_ERROR(Frontend, "Address to room must not be empty");
-                    return -1;
+                    return SDL_APP_FAILURE;
                 }
                 break;
             }
@@ -296,7 +306,7 @@ int main(int argc, char** argv) {
                 break;
             case 'v':
                 PrintVersion();
-                return -1;
+                return SDL_APP_FAILURE;
             case 'n':
                 force_null_render = true;
                 break;
@@ -358,79 +368,73 @@ int main(int argc, char** argv) {
 
     if (filepath.empty()) {
         LOG_CRITICAL(Frontend, "Failed to load ROM: No ROM specified");
-        return -1;
+        return SDL_APP_FAILURE;
     }
 
-    Core::System system{};
-    system.Initialize();
+    state->system.Initialize();
 
     InputCommon::InputSubsystem input_subsystem{};
 
     // Apply the command line arguments
-    system.ApplySettings();
+    state->system.ApplySettings();
 
-    std::unique_ptr<EmuWindow_SDL3> emu_window;
     switch (Settings::values.renderer_backend.GetValue()) {
 #ifdef HAS_OPENGL
     case Settings::RendererBackend::OpenGL_GLSL:
     case Settings::RendererBackend::OpenGL_GLASM:
     case Settings::RendererBackend::OpenGL_SPIRV:
-        emu_window = std::make_unique<EmuWindow_SDL3_GL>(&input_subsystem, system, fullscreen);
+        state->emu_window = std::make_unique<EmuWindow_SDL3_GL>(&input_subsystem, state->system, fullscreen);
         break;
 #endif
     case Settings::RendererBackend::Vulkan:
-        emu_window = std::make_unique<EmuWindow_SDL3_VK>(&input_subsystem, system, fullscreen);
+        state->emu_window = std::make_unique<EmuWindow_SDL3_VK>(&input_subsystem, state->system, fullscreen);
         break;
     case Settings::RendererBackend::Null:
-        emu_window = std::make_unique<EmuWindow_SDL3_Null>(&input_subsystem, system, fullscreen);
+        state->emu_window = std::make_unique<EmuWindow_SDL3_Null>(&input_subsystem, state->system, fullscreen);
         break;
     default:
         LOG_CRITICAL(Frontend, "Invalid renderer backend");
-        return -1;
+        return SDL_APP_FAILURE;
     }
 
 #ifdef _WIN32
     Common::Windows::SetCurrentTimerResolutionToMaximum();
-    system.CoreTiming().SetTimerResolutionNs(Common::Windows::GetCurrentTimerResolution());
+    state->system.CoreTiming().SetTimerResolutionNs(Common::Windows::GetCurrentTimerResolution());
 #endif
 
-    system.SetContentProvider(std::make_unique<FileSys::ContentProviderUnion>());
-    system.SetFilesystem(std::make_shared<FileSys::RealVfsFilesystem>());
-    system.GetFileSystemController().CreateFactories(*system.GetFilesystem());
-    system.GetUserChannel().clear();
+    state->system.SetContentProvider(std::make_unique<FileSys::ContentProviderUnion>());
+    state->system.SetFilesystem(std::make_shared<FileSys::RealVfsFilesystem>());
+    state->system.GetFileSystemController().CreateFactories(*state->system.GetFilesystem());
+    state->system.GetUserChannel().clear();
 
     Service::AM::FrontendAppletParameters load_parameters{
         .applet_id = Service::AM::AppletId::Application,
     };
-    const Core::SystemResultStatus load_result{system.Load(*emu_window, filepath, load_parameters)};
-
+    const Core::SystemResultStatus load_result = state->system.Load(*state->emu_window, filepath, load_parameters);
     switch (load_result) {
-    case Core::SystemResultStatus::ErrorGetLoader:
-        LOG_CRITICAL(Frontend, "Failed to obtain loader for {}!", filepath);
-        return -1;
-    case Core::SystemResultStatus::ErrorLoader:
-        LOG_CRITICAL(Frontend, "Failed to load ROM!");
-        return -1;
-    case Core::SystemResultStatus::ErrorNotInitialized:
-        LOG_CRITICAL(Frontend, "CPUCore not initialized");
-        return -1;
-    case Core::SystemResultStatus::ErrorVideoCore:
-        LOG_CRITICAL(Frontend, "Failed to initialize VideoCore!");
-        return -1;
     case Core::SystemResultStatus::Success:
         break; // Expected case
+    case Core::SystemResultStatus::ErrorGetLoader:
+        LOG_CRITICAL(Frontend, "Failed to obtain loader for {}!", filepath);
+        return SDL_APP_FAILURE;
+    case Core::SystemResultStatus::ErrorLoader:
+        LOG_CRITICAL(Frontend, "Failed to load ROM!");
+        return SDL_APP_FAILURE;
+    case Core::SystemResultStatus::ErrorNotInitialized:
+        LOG_CRITICAL(Frontend, "CPUCore not initialized");
+        return SDL_APP_FAILURE;
+    case Core::SystemResultStatus::ErrorVideoCore:
+        LOG_CRITICAL(Frontend, "Failed to initialize VideoCore!");
+        return SDL_APP_FAILURE;
     default:
-        if (static_cast<u32>(load_result) >
-            static_cast<u32>(Core::SystemResultStatus::ErrorLoader)) {
-            const u16 loader_id = static_cast<u16>(Core::SystemResultStatus::ErrorLoader);
-            const u16 error_id = static_cast<u16>(load_result) - loader_id;
-            LOG_CRITICAL(Frontend,
-                         "While attempting to load the ROM requested, an error occurred. Please "
-                         "refer to the Eden wiki for more information or the Eden discord for "
-                         "additional help.\n\nError Code: {:04X}-{:04X}\nError Description: {}",
-                         loader_id, error_id, static_cast<Loader::ResultStatus>(error_id));
-        }
-        break;
+        const u16 loader_id = u16(Core::SystemResultStatus::ErrorLoader);
+        const u16 error_id = u16(load_result) - loader_id;
+        LOG_CRITICAL(Frontend,
+            "While attempting to load the ROM requested, an error occurred. Please "
+            "refer to the Eden wiki for more information or the Eden discord for "
+            "additional help.\n\nError Code: {:04X}-{:04X}\nError Description: {}",
+            loader_id, error_id, Loader::ResultStatus(error_id));
+        return SDL_APP_FAILURE;
     }
 
     if (use_multiplayer) {
@@ -439,40 +443,46 @@ int main(int argc, char** argv) {
             member->BindOnStatusMessageReceived(OnStatusMessageReceived);
             member->BindOnStateChanged(OnStateChanged);
             member->BindOnError(OnNetworkError);
-            LOG_DEBUG(Network, "Start connection to {}:{} with nickname {}", address, port,
-                      nickname);
+            LOG_DEBUG(Network, "Start connection to {}:{} with nickname {}", address, port, nickname);
             member->Join(nickname, address.c_str(), port, 0, Network::NoPreferredIP, password);
         } else {
             LOG_ERROR(Network, "Could not access RoomMember");
-            return 0;
+            return SDL_APP_FAILURE;
         }
     }
 
     // Core is loaded, start the GPU (makes the GPU contexts current to this thread)
-    system.GPU().Start();
-    system.GetCpuManager().OnGpuReady();
+    state->system.GPU().Start();
+    state->system.GetCpuManager().OnGpuReady();
 
     if (Settings::values.use_disk_shader_cache.GetValue()) {
-        system.Renderer().ReadRasterizer()->LoadDiskResources(
-            system.GetApplicationProcessProgramID(), std::stop_token{},
+        state->system.Renderer().ReadRasterizer()->LoadDiskResources(
+            state->system.GetApplicationProcessProgramID(), std::stop_token{},
             [](VideoCore::LoadCallbackStage, size_t value, size_t total) {});
     }
 
-    system.RegisterExitCallback([&] {
-        // Just exit right away.
-        exit(0);
-    });
-    void(system.Run());
-    if (system.DebuggerEnabled()) {
-        system.InitializeDebugger();
-    }
-    while (emu_window->IsOpen()) {
-        emu_window->WaitEvent();
-    }
-    system.DetachDebugger();
-    void(system.Pause());
-    system.ShutdownMainProcess();
-    return 0;
+    // don't do anything, SDL3 already exists for us :D
+    state->system.RegisterExitCallback([] {});
+    void(state->system.Run());
+    if (state->system.DebuggerEnabled())
+        state->system.InitializeDebugger();
+    return SDL_APP_SUCCESS;
+}
+extern "C" SDL_AppResult SDL_AppIterate(void *appstate) {
+    SdlState *state = (SdlState *)appstate;
+    return state->emu_window->IsOpen() ? SDL_APP_CONTINUE : SDL_APP_SUCCESS;
+}
+extern "C" SDL_AppResult SDL_AppEvent(void *appstate, SDL_Event *event) {
+    SdlState *state = (SdlState *)appstate;
+    state->emu_window->OnEvent(*event);
+    return SDL_APP_SUCCESS;
+}
+extern "C" void SDL_AppQuit(void *appstate, SDL_AppResult result) {
+    SdlState *state = (SdlState *)appstate;
+    state->system.DetachDebugger();
+    void(state->system.Pause());
+    state->system.ShutdownMainProcess();
+    delete state;
 }
 
 #define VMA_IMPLEMENTATION