Skip to content

Xbox Cloud Gaming app for PS5 Homebrew

C
47.4 KB
Raw Blame
// SPDX-License-Identifier: GPL-3.0-or-later
// Copyright (C) 2026 RafaelNGP
#include "platform/platform.h"
#include "platform/toasts.h"
#include "util/log.h"

#include <cerrno>
#include <ctime>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>
#include <dlfcn.h>
#include <orbis/NetCtl.h>

#include <algorithm>
#include <arpa/inet.h>
#include <atomic>
#include <ifaddrs.h>
#include <net/if.h>
#include <netinet/in.h>
#include <netdb.h>
#include <poll.h>
#include <pthread.h>
#include <pthread_np.h>
#include <cstdarg>
#include <mutex>
#include <unordered_map>
#include <unordered_set>
#include <sys/ioctl.h>
#include <sys/select.h>
#include <sys/socket.h>

extern "C" {
int sceNetIoctl(int s, unsigned long cmd, void* data);
int sceNetSocket(const char* name, int domain, int type, int protocol);
int sceNetBind(int s, const void* addr, unsigned int addrlen);
int sceNetGetsockname(int s, void* addr, unsigned int* addrlen);
int sceNetSendto(int s, const void* msg, size_t len, int flags, const void* to, unsigned int tolen);
int sceNetRecvfrom(int s, void* buf, size_t len, int flags, void* from, unsigned int* fromlen);
int sceNetSend(int s, const void* msg, size_t len, int flags);
int sceNetRecv(int s, void* buf, size_t len, int flags);
int sceNetConnect(int s, const void* addr, unsigned int addrlen);
int sceNetListen(int s, int backlog);
int sceNetAccept(int s, void* addr, unsigned int* addrlen);
int sceNetSetsockopt(int s, int level, int optname, const void* optval, unsigned int optlen);
int sceNetGetsockopt(int s, int level, int optname, void* optval, unsigned int* optlen);
int sceNetSocketClose(int s);
int* sceNetErrnoLoc(void);
int _ioctl(int fd, unsigned long request, void* arg);
int _close(int fd);
int sceSysmoduleLoadModule(uint32_t id);
int sceSysmoduleLoadModuleInternal(uint32_t id);
int sceRandomGetRandomNumber(void* buf, size_t size);
int scePthreadCreate(pthread_t* thread, const pthread_attr_t* attr, void* (*entry)(void*), void* arg, const char* name);
pthread_t scePthreadSelf(void);
int scePthreadSetaffinity(pthread_t thread, uint64_t mask);
int scePthreadSetprio(pthread_t thread, int prio);
int sceKernelAvailableFlexibleMemorySize(size_t* sizeOut);

static std::mutex s_sockMutex;
static std::unordered_map<int, uint16_t> s_boundPorts;
static std::unordered_set<int> s_openSockets;

static bool isSocket(int fd) {
    if (fd < 0) return false;
    std::lock_guard<std::mutex> lock(s_sockMutex);
    return s_openSockets.find(fd) != s_openSockets.end();
}

static inline int getNetErrno(int ret) {
    uint32_t uret = static_cast<uint32_t>(ret);
    if ((uret & 0xFFFFFE00) == 0x80410000) {
        return static_cast<int>(uret & 0xFF);
    }
    int* err = sceNetErrnoLoc();
    if (err && *err > 0) {
        return *err;
    }
    if (ret < 0 && ret > -256) {
        return -ret;
    }
    return ret < 0 ? -ret : 0;
}

static inline int sanitizeNetFlags(int flags) {
    return flags & 0xC3;
}

static int setSocketNonBlock(int fd, int on) {
    if (int* err = sceNetErrnoLoc()) *err = 0;
    int rcNbio = sceNetSetsockopt(fd, 0xffff /*SOL_SOCKET*/, 0x1200 /*SO_NBIO*/, &on, sizeof(on));
    int errNbio = (rcNbio < 0) ? getNetErrno(rcNbio) : 0;

    if (int* err = sceNetErrnoLoc()) *err = 0;
    int rcIoctl = sceNetIoctl(fd, 0x8004667eUL /*FIONBIO*/, &on);
    int errIoctl = (rcIoctl < 0) ? getNetErrno(rcIoctl) : 0;

    if (rcNbio < 0 && rcIoctl < 0) {
        if (errNbio == EBADF || errNbio == ENOTSOCK ||
            errIoctl == EBADF || errIoctl == ENOTSOCK) {
            if (int* err = sceNetErrnoLoc()) *err = 0;
            return -1;
        }
    }
    static bool s_logged = false;
    if (!s_logged) {
        s_logged = true;
        XC_LOGI("net: setSocketNonBlock(fd=%d, on=%d): SO_NBIO=0x%08x, sceNetIoctl=0x%08x",
                fd, on, static_cast<unsigned>(rcNbio), static_cast<unsigned>(rcIoctl));
    }
    if (rcNbio >= 0 || rcIoctl >= 0) {
        if (int* err = sceNetErrnoLoc()) *err = 0;
        return 0;
    }
    if (on != 0) {
        int us = 50000;
        if (sceNetSetsockopt(fd, 0xffff /*SOL_SOCKET*/, 0x1006 /*SO_RCVTIMEO*/, &us, sizeof(us)) < 0) {
            struct timeval tv{0, 50000};
            sceNetSetsockopt(fd, 0xffff /*SOL_SOCKET*/, 0x1006 /*SO_RCVTIMEO*/, &tv, sizeof(tv));
        }
    }
    if (int* err = sceNetErrnoLoc()) *err = 0;
    return 0;
}

int ioctl(int fd, unsigned long request, ...) {
    void* arg = nullptr;
    va_list ap;
    va_start(ap, request);
    arg = va_arg(ap, void*);
    va_end(ap);

    if (request == 0x5421 || request == 0x8004667eUL || request == FIONBIO) {
        int on = arg ? (*reinterpret_cast<const int*>(arg) ? 1 : 0) : 1;
        setSocketNonBlock(fd, on);
        return 0;
    }

    // On PS4/shadPS4, socket ioctls like FIONREAD must be routed to sceNetIoctl.
    int rc = sceNetIoctl(fd, request, arg);
    if (rc >= 0) {
        return rc;
    }
    if (int* err = sceNetErrnoLoc()) *err = 0;
    return _ioctl(fd, request, arg);
}

int fcntl(int fd, int cmd, ...) {
    void* arg = nullptr;
    va_list ap;
    va_start(ap, cmd);
    arg = va_arg(ap, void*);
    va_end(ap);

    if (cmd == F_SETFL) {
        long flags = reinterpret_cast<intptr_t>(arg);
        int on = (flags & O_NONBLOCK) ? 1 : 0;
        if (isSocket(fd)) {
            return setSocketNonBlock(fd, on);
        }
    } else if (cmd == F_GETFL) {
        typedef int (*RealFcntlFn)(int, int, ...);
        static RealFcntlFn real_fcntl = nullptr;
        if (!real_fcntl) {
            real_fcntl = reinterpret_cast<RealFcntlFn>(dlsym(RTLD_NEXT, "fcntl"));
        }
        if (real_fcntl) {
            int ret = real_fcntl(fd, cmd);
            if (ret >= 0) return ret;
        }
        return 0;
    }

    typedef int (*RealFcntlFn)(int, int, ...);
    static RealFcntlFn real_fcntl = nullptr;
    if (!real_fcntl) {
        real_fcntl = reinterpret_cast<RealFcntlFn>(dlsym(RTLD_NEXT, "fcntl"));
    }
    if (real_fcntl) {
        return real_fcntl(fd, cmd, arg);
    }
    return 0;
}


// The OpenOrbis headers carry musl's _SC_* numbering, but the only sysconf() the linker
// finds is Sony's libkernel one (FreeBSD numbering). libc++'s hardware_concurrency()
// calls sysconf(84): musl's _SC_NPROCESSORS_ONLN, FreeBSD's _SC_THREAD_CPUTIME. Whatever
// libkernel answers then becomes the size of libdatachannel's ThreadPool (rtc::impl::Init
// spawns max(hardware_concurrency(), MIN_THREADPOOL_SIZE) threads at the first
// PeerConnection). 4XCLOUD links musl's own sysconf for this; here the musl numbers are
// answered directly. hardware_concurrency() is the only caller in the binary.
long sysconf(int name) {
    switch (name) {
    case 83:  // musl _SC_NPROCESSORS_CONF
    case 84:  // musl _SC_NPROCESSORS_ONLN
        return 6;  // cores 0-5 are the title's (the affinity masks use 0x3F)
    case 30:  // musl _SC_PAGESIZE
        return 16384;
    case 2:  // musl _SC_CLK_TCK
        return 100;
    case 4:  // musl _SC_OPEN_MAX
        return 1024;
    default:
        errno = EINVAL;
        return -1;
    }
}

// The same mismatch breaks clock_gettime(): musl's CLOCK_MONOTONIC is 1, which libkernel
// (FreeBSD numbering, MONOTONIC = 4) reads as CLOCK_VIRTUAL, the process's CPU time.
// Every timer then ran 1-3x too fast with the CPU load: platform::nowMs(), libc++'s
// steady_clock (libdatachannel's ThreadPool, DTLS and RTCP timers, condition-variable
// timeouts), the stream watchdogs and the crash guard. The musl ids are translated here;
// this definition replaces libkernel's for the whole binary.
int sceKernelClockGettime(int clockId, struct timespec* tp);

int clock_gettime(clockid_t id, struct timespec* ts) {
    int sceId;
    switch (id) {
    case 0:  // musl CLOCK_REALTIME
    case 5:  // musl CLOCK_REALTIME_COARSE
        sceId = 0;  // FreeBSD CLOCK_REALTIME
        break;
    case 1:  // musl CLOCK_MONOTONIC
    case 4:  // musl CLOCK_MONOTONIC_RAW
    case 6:  // musl CLOCK_MONOTONIC_COARSE
        sceId = 4;  // FreeBSD CLOCK_MONOTONIC
        break;
    case 7:  // musl CLOCK_BOOTTIME
        sceId = 5;  // FreeBSD CLOCK_UPTIME
        break;
    case 2:  // musl CLOCK_PROCESS_CPUTIME_ID
        sceId = 15;
        break;
    case 3:  // musl CLOCK_THREAD_CPUTIME_ID
        sceId = 14;
        break;
    default:
        errno = EINVAL;
        return -1;
    }
    int rc = sceKernelClockGettime(sceId, ts);
    if (rc != 0) {
        errno = (rc & 0xFF) ? (rc & 0xFF) : EINVAL;
        return -1;
    }
    return 0;
}

static std::atomic<int> s_threadsCreated{0};
static std::atomic<int> s_threadsLive{0};
static std::atomic<int> s_threadFailures{0};

// Counts the threads still running: the key's destructor runs when a thread ends,
// whether it returns or calls pthread_exit.
static pthread_key_t s_liveKey;
static std::once_flag s_liveKeyOnce;
static bool s_liveKeyOk = false;

struct ThreadStart {
    void* (*fn)(void*);
    void* arg;
};

static void* threadTrampoline(void* p) {
    ThreadStart start = *static_cast<ThreadStart*>(p);
    delete static_cast<ThreadStart*>(p);
    if (s_liveKeyOk) {
        s_threadsLive.fetch_add(1, std::memory_order_relaxed);
        pthread_setspecific(s_liveKey, reinterpret_cast<void*>(1));
    }
    return start.fn(start.arg);
}

int pthread_create(pthread_t* thread, const pthread_attr_t* attr,
                   void* (*start_routine)(void*), void* arg) {
    if (!thread || !start_routine) {
        return EINVAL;
    }
    std::call_once(s_liveKeyOnce, [] {
        s_liveKeyOk = pthread_key_create(&s_liveKey, [](void*) {
            s_threadsLive.fetch_sub(1, std::memory_order_relaxed);
        }) == 0;
    });

    pthread_attr_t customAttr;
    bool createdAttr = false;

    if (!attr) {
        if (pthread_attr_init(&customAttr) == 0) {
            pthread_attr_setstacksize(&customAttr, 1024 * 1024); // 1 MB stack
            attr = &customAttr;
            createdAttr = true;
        }
    }

    typedef int (*RealPthreadCreateFn)(pthread_t*, const pthread_attr_t*, void* (*)(void*), void*);
    static RealPthreadCreateFn real_pthread_create = nullptr;
    static bool s_resolved = false;
    if (!s_resolved) {
        s_resolved = true;
        void* sym = dlsym(RTLD_NEXT, "pthread_create");
        if (sym && sym != reinterpret_cast<void*>(&pthread_create)) {
            real_pthread_create = reinterpret_cast<RealPthreadCreateFn>(sym);
        }
        XC_LOGI("threads: created with %s, %ld cores reported, default stack 1 MB",
                real_pthread_create ? "libkernel pthread_create (dlsym)" : "scePthreadCreate",
                sysconf(84 /*musl _SC_NPROCESSORS_ONLN*/));
    }

    size_t stackBytes = 0;
    if (attr) pthread_attr_getstacksize(attr, &stackBytes);

    auto* start = new ThreadStart{start_routine, arg};
    int rc = -1;
    if (real_pthread_create) {
        rc = real_pthread_create(thread, attr, threadTrampoline, start);
    }
    int realRc = rc;
    int sceRc = 0;
    if (rc != 0) {
        rc = scePthreadCreate(thread, attr, threadTrampoline, start, "xcloud_worker");
        sceRc = rc;
        if (rc < 0) {
            uint32_t uret = static_cast<uint32_t>(rc);
            rc = ((uret & 0xFFFF0000) == 0x80020000) ? static_cast<int>(uret & 0xFFFF) : EAGAIN;
        }
    }

    if (createdAttr) {
        pthread_attr_destroy(&customAttr);
    }
    if (rc == 0) {
        s_threadsCreated.fetch_add(1, std::memory_order_relaxed);
    } else {
        delete start;
        // The first few, then every 100th: a runaway loop must not flood the log.
        int n = s_threadFailures.fetch_add(1) + 1;
        if (n <= 3 || n % 100 == 0) {
            XC_LOGE("pthread_create failed #%d: rc=%d %s (sce 0x%08x, pthread_create %d), stack %zu KB; %s", n, rc,
                    std::strerror(rc), static_cast<unsigned>(sceRc), realRc, stackBytes >> 10,
                    xc::platform::diagnostics().c_str());
        }
    }
    return rc;
}

int socket(int domain, int type, int protocol) {
    if (protocol == 17) {
        protocol = 0;
    }
    int baseType = type & 0xF;
    int s = sceNetSocket("", domain, baseType, protocol);
    if (s < 0) {
        errno = getNetErrno(s);
        XC_LOGW("net: sceNetSocket(domain=%d, type=0x%x, proto=%d) failed: 0x%08x (errno=%d)",
                domain, type, protocol, static_cast<unsigned>(s), errno);
        return -1;
    }
    {
        std::lock_guard<std::mutex> lock(s_sockMutex);
        s_openSockets.insert(s);
    }
#ifndef SOCK_NONBLOCK
#define SOCK_NONBLOCK 04000
#endif
    if ((type & SOCK_NONBLOCK) || (type & 04000) || (type & 0x800) || (type & 0x4000) || (type & 0x20000000)) {
        setSocketNonBlock(s, 1);
    }
    if (baseType == SOCK_DGRAM) {
        const int rcvCandidates[] = { 2097152, 1048576, 524288, 262144, 131072 };
        for (int sz : rcvCandidates) {
            if (sceNetSetsockopt(s, 0xffff /*SOL_SOCKET*/, 0x1002 /*SO_RCVBUF*/, &sz, sizeof(sz)) >= 0) {
                break;
            }
        }
        const int sndCandidates[] = { 1048576, 524288, 262144, 131072 };
        for (int sz : sndCandidates) {
            if (sceNetSetsockopt(s, 0xffff /*SOL_SOCKET*/, 0x1001 /*SO_SNDBUF*/, &sz, sizeof(sz)) >= 0) {
                break;
            }
        }
    }
    return s;
}

int bind(int fd, const struct sockaddr* addr, socklen_t len) {
    if (!addr || len < sizeof(struct sockaddr_in)) {
        int rc = sceNetBind(fd, addr, len);
        if (rc < 0) { errno = getNetErrno(rc); return -1; }
        return rc;
    }
    const auto* raw = reinterpret_cast<const uint8_t*>(addr);
    uint16_t port = 0;
    std::memcpy(&port, raw + 2, sizeof(port));
    port = ntohs(port);

    struct sockaddr_in boundAddr{};
    std::memcpy(&boundAddr, addr, std::min<size_t>(len, sizeof(boundAddr)));
    if (boundAddr.sin_family == 0 && raw[0] == AF_INET) {
        boundAddr.sin_family = AF_INET;
        boundAddr.sin_len = sizeof(struct sockaddr_in);
    } else if (boundAddr.sin_len == 0 || boundAddr.sin_len < sizeof(struct sockaddr_in)) {
        boundAddr.sin_len = sizeof(struct sockaddr_in);
    }
    if (boundAddr.sin_family == 0) boundAddr.sin_family = AF_INET;

    // Port 0 lets the stack pick a free ephemeral port. Forcing a fixed high
    // range (old 50100+) collides with ports the PS4 network stack reserves.
    int rc = sceNetBind(fd, &boundAddr, sizeof(boundAddr));
    if (rc < 0) {
        errno = getNetErrno(rc);
        XC_LOGW("net: sceNetBind(fd=%d, port=%u) failed: 0x%08x (errno=%d)",
                fd, static_cast<unsigned>(port), static_cast<unsigned>(rc), errno);
        return -1;
    }
    if (port != 0) {
        std::lock_guard<std::mutex> lock(s_sockMutex);
        s_boundPorts[fd] = port;
    } else {
        struct sockaddr_in actual{};
        unsigned int actualLen = sizeof(actual);
        if (sceNetGetsockname(fd, &actual, &actualLen) == 0 && actual.sin_port != 0) {
            std::lock_guard<std::mutex> lock(s_sockMutex);
            s_boundPorts[fd] = ntohs(actual.sin_port);
        } else {
            std::lock_guard<std::mutex> lock(s_sockMutex);
            if (s_boundPorts.find(fd) == s_boundPorts.end()) {
                s_boundPorts[fd] = static_cast<uint16_t>(50100 + (fd % 1000));
            }
        }
    }
    return 0;
}

int getsockname(int fd, struct sockaddr* addr, socklen_t* len) {
    if (!addr || !len || *len < sizeof(struct sockaddr_in)) return -1;
    {
        unsigned int nlen = static_cast<unsigned int>(*len);
        if (sceNetGetsockname(fd, addr, &nlen) == 0) {
            auto* sin = reinterpret_cast<struct sockaddr_in*>(addr);
            const auto* raw = reinterpret_cast<const uint8_t*>(addr);
            if (raw[0] == AF_INET && raw[1] == 0) {
                sin->sin_len = sizeof(struct sockaddr_in);
                sin->sin_family = AF_INET;
            } else if (sin->sin_family == AF_INET || sin->sin_family == AF_INET6) {
                if (sin->sin_len == 0) sin->sin_len = sizeof(struct sockaddr_in);
            }
            if (sin->sin_port == 0) {
                std::lock_guard<std::mutex> lock(s_sockMutex);
                auto it = s_boundPorts.find(fd);
                if (it != s_boundPorts.end()) {
                    sin->sin_port = htons(it->second);
                } else {
                    uint16_t fallbackPort = static_cast<uint16_t>(50100 + (fd % 1000));
                    s_boundPorts[fd] = fallbackPort;
                    sin->sin_port = htons(fallbackPort);
                }
            } else {
                std::lock_guard<std::mutex> lock(s_sockMutex);
                s_boundPorts[fd] = ntohs(sin->sin_port);
            }
            *len = nlen;
            return 0;
        }
    }
    uint16_t port = 0;
    {
        std::lock_guard<std::mutex> lock(s_sockMutex);
        auto it = s_boundPorts.find(fd);
        if (it != s_boundPorts.end()) {
            port = it->second;
        } else {
            port = static_cast<uint16_t>(50100 + (fd % 1000));
            s_boundPorts[fd] = port;
        }
    }
    auto* sin = reinterpret_cast<struct sockaddr_in*>(addr);
    std::memset(sin, 0, sizeof(*sin));
    sin->sin_len = sizeof(struct sockaddr_in);
    sin->sin_family = AF_INET;
    sin->sin_port = htons(port);
    sin->sin_addr.s_addr = 0; // INADDR_ANY so addr_is_any returns true
    *len = sizeof(struct sockaddr_in);
    return 0;
}

ssize_t sendto(int fd, const void* buf, size_t len, int flags,
               const struct sockaddr* dest_addr, socklen_t addrlen) {
    flags = sanitizeNetFlags(flags);
    if (!dest_addr || addrlen < 2) {
        int ret = sceNetSendto(fd, buf, len, flags, nullptr, 0);
        if (ret < 0) {
            errno = getNetErrno(ret);
            return -1;
        }
        return ret;
    }

    struct sockaddr_storage fixedAddr{};
    std::memcpy(&fixedAddr, dest_addr, std::min<size_t>(addrlen, sizeof(fixedAddr)));
    if (fixedAddr.ss_family == 0 && reinterpret_cast<const uint8_t*>(dest_addr)[0] == AF_INET) {
        fixedAddr.ss_family = AF_INET;
        fixedAddr.ss_len = sizeof(struct sockaddr_in);
    } else if (fixedAddr.ss_len == 0) {
        fixedAddr.ss_len = (fixedAddr.ss_family == AF_INET6) ? sizeof(struct sockaddr_in6) : sizeof(struct sockaddr_in);
    }

    int ret = sceNetSendto(fd, buf, len, flags, &fixedAddr, addrlen);
    if (ret < 0) {
        errno = getNetErrno(ret);
        return -1;
    }
    return ret;
}

ssize_t recvfrom(int fd, void* buf, size_t len, int flags,
                 struct sockaddr* src_addr, socklen_t* addrlen) {
    flags = sanitizeNetFlags(flags);
    unsigned int slen = addrlen ? static_cast<unsigned int>(*addrlen) : 0;
    int ret = sceNetRecvfrom(fd, buf, len, flags, src_addr, addrlen ? &slen : nullptr);
    if (ret < 0) {
        int err = getNetErrno(ret);
        errno = (err == ETIMEDOUT) ? EAGAIN : err;
        return -1;
    }
    if (addrlen) *addrlen = slen;
    if (src_addr && slen >= sizeof(struct sockaddr_in)) {
        auto* sin = reinterpret_cast<struct sockaddr_in*>(src_addr);
        if (sin->sin_len == 0) sin->sin_len = sizeof(struct sockaddr_in);
        if (sin->sin_family == 0) sin->sin_family = AF_INET;
    }
    return ret;
}

ssize_t send(int fd, const void* buf, size_t len, int flags) {
    int ret = sceNetSend(fd, buf, len, sanitizeNetFlags(flags));
    if (ret < 0) {
        errno = getNetErrno(ret);
        return -1;
    }
    return ret;
}

ssize_t recv(int fd, void* buf, size_t len, int flags) {
    int ret = sceNetRecv(fd, buf, len, sanitizeNetFlags(flags));
    if (ret < 0) {
        int err = getNetErrno(ret);
        errno = (err == ETIMEDOUT) ? EAGAIN : err;
        return -1;
    }
    return ret;
}

int connect(int fd, const struct sockaddr* addr, socklen_t len) {
    if (!addr) return -1;
    struct sockaddr_storage fixedAddr{};
    std::memcpy(&fixedAddr, addr, std::min<size_t>(len, sizeof(fixedAddr)));
    if (fixedAddr.ss_family == 0 && reinterpret_cast<const uint8_t*>(addr)[0] == AF_INET) {
        fixedAddr.ss_family = AF_INET;
        fixedAddr.ss_len = sizeof(struct sockaddr_in);
    } else if (fixedAddr.ss_len == 0) {
        fixedAddr.ss_len = (fixedAddr.ss_family == AF_INET6) ? sizeof(struct sockaddr_in6) : sizeof(struct sockaddr_in);
    }
    int ret = sceNetConnect(fd, &fixedAddr, len);
    if (ret < 0) {
        errno = getNetErrno(ret);
        return -1;
    }
    return ret;
}

int listen(int fd, int backlog) {
    int ret = sceNetListen(fd, backlog);
    if (ret < 0) {
        errno = getNetErrno(ret);
        return -1;
    }
    return ret;
}

int accept(int fd, struct sockaddr* addr, socklen_t* addrlen) {
    unsigned int slen = addrlen ? static_cast<unsigned int>(*addrlen) : 0;
    int ret = sceNetAccept(fd, addr, addrlen ? &slen : nullptr);
    if (ret < 0) {
        errno = getNetErrno(ret);
        return -1;
    }
    {
        std::lock_guard<std::mutex> lock(s_sockMutex);
        s_openSockets.insert(ret);
    }
    if (addrlen) *addrlen = slen;
    return ret;
}

static inline void translateSockOpt(int& level, int& optname) {
    if (level == 1) { // Linux SOL_SOCKET
        level = 0xffff; // FreeBSD / Orbis SOL_SOCKET
        switch (optname) {
            case 1:  optname = 0x0001; break; // SO_DEBUG
            case 2:  optname = 0x0004; break; // SO_REUSEADDR
            case 3:  optname = 0x1008; break; // SO_TYPE
            case 4:  optname = 0x1007; break; // SO_ERROR
            case 5:  optname = 0x0010; break; // SO_DONTROUTE
            case 6:  optname = 0x0020; break; // SO_BROADCAST
            case 7:  optname = 0x1001; break; // SO_SNDBUF
            case 8:  optname = 0x1002; break; // SO_RCVBUF
            case 9:  optname = 0x0008; break; // SO_KEEPALIVE
            case 10: optname = 0x0100; break; // SO_OOBINLINE
            case 13: optname = 0x0080; break; // SO_LINGER
            case 15: optname = 0x0200; break; // SO_REUSEPORT
            case 18: optname = 0x1004; break; // SO_RCVLOWAT
            case 19: optname = 0x1003; break; // SO_SNDLOWAT
            case 20: optname = 0x1006; break; // SO_RCVTIMEO
            case 21: optname = 0x1005; break; // SO_SNDTIMEO
            default: break;
        }
    }
}

int setsockopt(int fd, int level, int optname, const void* optval, socklen_t optlen) {
    translateSockOpt(level, optname);
    int ret = sceNetSetsockopt(fd, level, optname, optval, optlen);
    if (ret < 0 && level == 0xffff && (optname == 0x1002 || optname == 0x1001) && optval && optlen == sizeof(int)) {
        int req = *reinterpret_cast<const int*>(optval);
        int step = req / 2;
        while (step >= 65536) {
            ret = sceNetSetsockopt(fd, level, optname, &step, sizeof(step));
            if (ret >= 0) break;
            step /= 2;
        }
    }
    if (ret < 0) {
        errno = getNetErrno(ret);
        return -1;
    }
    return 0;
}

int getsockopt(int fd, int level, int optname, void* optval, socklen_t* optlen) {
    translateSockOpt(level, optname);
    unsigned int olen = optlen ? static_cast<unsigned int>(*optlen) : 0;
    int ret = sceNetGetsockopt(fd, level, optname, optval, optlen ? &olen : nullptr);
    if (ret < 0) {
        errno = getNetErrno(ret);
        return -1;
    }
    if (optlen) *optlen = olen;
    return 0;
}

int close(int fd) {
    {
        std::lock_guard<std::mutex> lock(s_sockMutex);
        s_boundPorts.erase(fd);
        s_openSockets.erase(fd);
    }
    int netRet = sceNetSocketClose(fd);
    if (netRet >= 0) {
        return 0;
    }
    if (int* err = sceNetErrnoLoc()) *err = 0;
    return _close(fd);
}
}

extern "C" void arc4random_buf(void* buf, size_t n) {
    if (buf && n > 0) {
        sceRandomGetRandomNumber(buf, n);
    }
}

extern "C" int mbedtls_hardware_poll(void* /*data*/, unsigned char* output, size_t len, size_t* olen) {
    arc4random_buf(output, len);
    *olen = len;
    return 0;
}

extern "C" uint32_t ntohl(uint32_t netlong) {
    return __builtin_bswap32(netlong);
}

extern "C" uint32_t htonl(uint32_t hostlong) {
    return __builtin_bswap32(hostlong);
}

extern "C" uint16_t ntohs(uint16_t netshort) {
    return __builtin_bswap16(netshort);
}

extern "C" uint16_t htons(uint16_t hostshort) {
    return __builtin_bswap16(hostshort);
}

extern "C" int inet_pton(int af, const char* src, void* dst) {
    if (af != AF_INET || !src || !dst) return 0;
    unsigned int a, b, c, d;
    char tail = 0;
    if (std::sscanf(src, "%u.%u.%u.%u%c", &a, &b, &c, &d, &tail) == 4) {
        if (a <= 255 && b <= 255 && c <= 255 && d <= 255) {
            uint8_t* p = static_cast<uint8_t*>(dst);
            p[0] = static_cast<uint8_t>(a);
            p[1] = static_cast<uint8_t>(b);
            p[2] = static_cast<uint8_t>(c);
            p[3] = static_cast<uint8_t>(d);
            return 1;
        }
    }
    return 0;
}

extern "C" const char* inet_ntop(int af, const void* src, char* dst, socklen_t size) {
    if (!src || !dst) return nullptr;
    if (af == AF_INET) {
        if (size < 16) return nullptr;
        const auto* p = static_cast<const uint8_t*>(src);
        int n = std::snprintf(dst, size, "%u.%u.%u.%u", p[0], p[1], p[2], p[3]);
        if (n < 0 || static_cast<socklen_t>(n) >= size) return nullptr;
        return dst;
    }
    if (af == AF_INET6) {
        if (size < 46) return nullptr;
        const auto* p = static_cast<const uint8_t*>(src);
        uint16_t words[8];
        for (int i = 0; i < 8; ++i) {
            uint16_t w = 0;
            std::memcpy(&w, p + i * 2, sizeof(w));
            words[i] = ntohs(w);
        }
        int n = std::snprintf(dst, size, "%x:%x:%x:%x:%x:%x:%x:%x",
                              words[0], words[1], words[2], words[3],
                              words[4], words[5], words[6], words[7]);
        if (n < 0 || static_cast<socklen_t>(n) >= size) return nullptr;
        return dst;
    }
    return nullptr;
}

extern "C" int getnameinfo(const struct sockaddr* sa, socklen_t salen,
                           char* host, socklen_t hostlen,
                           char* serv, socklen_t servlen,
                           int flags) {
    (void)salen;
    (void)flags;
    if (!sa) return EAI_FAIL;

    const auto* raw = reinterpret_cast<const uint8_t*>(sa);
    int family = -1;
    if (raw[0] == AF_INET || raw[1] == AF_INET) {
        family = AF_INET;
    } else if (raw[0] == 28 || raw[1] == 28 || raw[0] == 10 || raw[1] == 10) {
        family = AF_INET6;
    } else {
        return EAI_FAMILY;
    }

    int port = 0;
    if (family == AF_INET) {
        uint16_t netport = 0;
        std::memcpy(&netport, raw + 2, sizeof(netport));
        port = ntohs(netport);

        if (host && hostlen > 0) {
            int n = std::snprintf(host, hostlen, "%u.%u.%u.%u", raw[4], raw[5], raw[6], raw[7]);
            if (n < 0 || static_cast<socklen_t>(n) >= hostlen) return EAI_OVERFLOW;
        }
    } else {
        uint16_t netport = 0;
        std::memcpy(&netport, raw + 2, sizeof(netport));
        port = ntohs(netport);

        if (host && hostlen > 0) {
            uint16_t words[8];
            for (int i = 0; i < 8; ++i) {
                uint16_t w = 0;
                std::memcpy(&w, raw + 8 + i * 2, sizeof(w));
                words[i] = ntohs(w);
            }
            int n = std::snprintf(host, hostlen, "%x:%x:%x:%x:%x:%x:%x:%x",
                                  words[0], words[1], words[2], words[3],
                                  words[4], words[5], words[6], words[7]);
            if (n < 0 || static_cast<socklen_t>(n) >= hostlen) return EAI_OVERFLOW;
        }
    }

    if (serv && servlen > 0) {
        int n = std::snprintf(serv, servlen, "%d", port);
        if (n < 0 || static_cast<socklen_t>(n) >= servlen) return EAI_OVERFLOW;
    }
    return 0;
}

extern "C" int poll(struct pollfd* fds, nfds_t nfds, int timeout) {
    fd_set readfds, writefds, exceptfds;
    FD_ZERO(&readfds);
    FD_ZERO(&writefds);
    FD_ZERO(&exceptfds);
    int maxfd = -1;
    for (nfds_t i = 0; i < nfds; ++i) {
        fds[i].revents = 0;
        if (fds[i].fd < 0 || fds[i].fd >= FD_SETSIZE) continue;
        if (fds[i].events & (POLLIN | POLLPRI)) FD_SET(fds[i].fd, &readfds);
        if (fds[i].events & POLLOUT) FD_SET(fds[i].fd, &writefds);
        FD_SET(fds[i].fd, &exceptfds);
        if (fds[i].fd > maxfd) maxfd = fds[i].fd;
    }
    struct timeval tv{};
    struct timeval* ptv = nullptr;
    if (timeout >= 0) {
        tv.tv_sec = timeout / 1000;
        tv.tv_usec = (timeout % 1000) * 1000;
        ptv = &tv;
    }
    if (maxfd < 0) {
        if (timeout > 0) usleep(static_cast<useconds_t>(timeout) * 1000);
        return 0;
    }
    int rc = select(maxfd + 1, &readfds, &writefds, &exceptfds, ptv);
    if (rc <= 0) return rc;
    int count = 0;
    for (nfds_t i = 0; i < nfds; ++i) {
        if (fds[i].fd < 0 || fds[i].fd >= FD_SETSIZE) continue;
        short rev = 0;
        if (FD_ISSET(fds[i].fd, &readfds)) rev |= POLLIN;
        if (FD_ISSET(fds[i].fd, &writefds)) rev |= POLLOUT;
        if (FD_ISSET(fds[i].fd, &exceptfds)) rev |= POLLERR;
        fds[i].revents = rev;
        if (rev) count++;
    }
    return count;
}

extern "C" int __cxa_thread_atexit_impl(void (*)(void*), void*, void*) {
    return 0;
}

extern "C" int getifaddrs(struct ifaddrs** ifap) {
    if (!ifap) return -1;
    *ifap = nullptr;

    struct sockaddr_in local{};
    local.sin_family = AF_INET;
    local.sin_len = sizeof(struct sockaddr_in);

    struct sockaddr_in mask{};
    mask.sin_family = AF_INET;
    mask.sin_len = sizeof(struct sockaddr_in);
    mask.sin_addr.s_addr = htonl(0xFFFFFF00);

    const char* src = "none";
    // 1. Query sceNetCtlGetInfo from libSceNetCtl
    OrbisNetCtlInfo info{};
    int ctlRc = sceNetCtlGetInfo(14 /*ORBIS_NET_CTL_INFO_IP_ADDRESS*/, &info);
    if (ctlRc != 0) {
        sceNetCtlInit();
        ctlRc = sceNetCtlGetInfo(14, &info);
    }
    if (ctlRc != 0 || info.ip_address[0] == '\0') {
        ctlRc = sceNetCtlGetInfo(16 /*SCE_NET_CTL_INFO_IP_ADDRESS fallback*/, &info);
    }
    if (ctlRc == 0 && info.ip_address[0] != '\0') {
        info.ip_address[sizeof(info.ip_address) - 1] = '\0';
        inet_pton(AF_INET, info.ip_address, &local.sin_addr);
        src = "sceNetCtlGetInfo";

        OrbisNetCtlInfo maskInfo{};
        if (sceNetCtlGetInfo(15 /*ORBIS_NET_CTL_INFO_NETMASK*/, &maskInfo) == 0 && maskInfo.netmask[0] != '\0') {
            maskInfo.netmask[sizeof(maskInfo.netmask) - 1] = '\0';
            inet_pton(AF_INET, maskInfo.netmask, &mask.sin_addr);
        }
    }

    // 2. Fallback: Connect UDP socket to 8.8.8.8:53 to query kernel routing
    if (local.sin_addr.s_addr == 0) {
        int s = socket(AF_INET, SOCK_DGRAM, 0);
        if (s >= 0) {
            struct sockaddr_in probe{};
            probe.sin_len = sizeof(probe);
            probe.sin_family = AF_INET;
            probe.sin_port = htons(53);
            probe.sin_addr.s_addr = htonl(0x08080808); // 8.8.8.8
            if (connect(s, reinterpret_cast<struct sockaddr*>(&probe), sizeof(probe)) == 0) {
                socklen_t localLen = sizeof(local);
                getsockname(s, reinterpret_cast<struct sockaddr*>(&local), &localLen);
                if (local.sin_addr.s_addr != 0) src = "udp-route-probe";
            }
            close(s);
        }
    }

    // 3. Fallback: /data/psbox/local_ip.txt override file
    if (local.sin_addr.s_addr == 0) {
        FILE* fp = std::fopen("/data/psbox/local_ip.txt", "r");
        if (fp) {
            char buf[64]{};
            if (std::fgets(buf, sizeof(buf), fp)) {
                char* nl = std::strpbrk(buf, "\r\n ");
                if (nl) *nl = '\0';
                inet_pton(AF_INET, buf, &local.sin_addr);
                if (local.sin_addr.s_addr != 0) src = "local_ip.txt";
            }
            std::fclose(fp);
        }
    }

    // 4. Default fallback: ensure libjuice never receives an empty interface list
    if (local.sin_addr.s_addr == 0) {
        inet_pton(AF_INET, "127.0.0.1", &local.sin_addr);
        src = "loopback-default";
    }
    static const char* s_lastIfSrc = nullptr;
    if (s_lastIfSrc != src) {
        s_lastIfSrc = src;
        XC_LOGI("net: getifaddrs resolved eth0 via %s (ctlRc=0x%08x)", src, static_cast<unsigned>(ctlRc));
    }
    local.sin_family = AF_INET;
    local.sin_len = sizeof(struct sockaddr_in);

    struct Entry {
        struct ifaddrs ifa;
        struct sockaddr_in addr;
        struct sockaddr_in mask;
        char name[16];
    };

    auto* e = static_cast<Entry*>(std::calloc(1, sizeof(Entry)));
    if (!e) return -1;

    std::strncpy(e->name, "eth0", sizeof(e->name) - 1);
    e->addr = local;
    e->mask = mask;

    e->ifa.ifa_next = nullptr;
    e->ifa.ifa_name = e->name;
    e->ifa.ifa_flags = IFF_UP | IFF_RUNNING | IFF_BROADCAST | IFF_MULTICAST;
    e->ifa.ifa_addr = reinterpret_cast<struct sockaddr*>(&e->addr);
    e->ifa.ifa_netmask = reinterpret_cast<struct sockaddr*>(&e->mask);

    *ifap = &e->ifa;
    return 0;
}

extern "C" void freeifaddrs(struct ifaddrs* ifa) {
    while (ifa) {
        struct ifaddrs* next = ifa->ifa_next;
        std::free(ifa);
        ifa = next;
    }
}

extern "C" {
struct SceKernelSwVersion {
    uint64_t size;
    char versionString[0x1C];
    uint32_t version;
};
int sceKernelGetSystemSwVersion(SceKernelSwVersion* version);
int sceSystemServiceLoadExec(const char* path, char* const argv[]);
int sceKernelSendNotificationRequest(int device, void* request, size_t size, int blocking);
int sceNetInit(void);
int sceNetPoolCreate(const char* name, int size, int flags);
int sceNetResolverCreate(const char* name, int memid, int flags);
int sceNetResolverStartNtoa(int rid, const char* hostname, uint32_t* addr, int timeout, int retry, int flags);

struct SceNetInAddr {
    uint32_t s_addr;
};

union SceNetAddrUnion {
    SceNetInAddr addr;
    uint8_t addr6[16];
};

struct SceNetResolverAddr {
    SceNetAddrUnion u;
    uint32_t af;
    uint32_t reserved[3];
};

struct SceNetResolverInfo {
    SceNetResolverAddr addrs[10];
    uint32_t records;
    uint32_t recordsv4;
    uint32_t reserved[14];
};

int sceNetResolverStartNtoaMultipleRecords(int rid, const char* hostname, SceNetResolverInfo* info, int timeout, int retry, int flags);
int sceNetResolverDestroy(int rid);
int sceKernelAvailableDirectMemorySize(off_t start, off_t end, size_t align, off_t* startOut, size_t* sizeOut);
size_t sceKernelGetDirectMemorySize(void);
int sceKernelIsNeoMode(void);
}

namespace xc::platform {

namespace {
constexpr const char* kDataDir = "/data/psbox";
constexpr const char* kLegacyDir = "/data/homebrew/PSBX00001";
std::string g_dataDir = kDataDir;
std::string g_dataNote;
bool g_dataDirWritable = false;
int g_dataDirErrno = 0;
std::atomic<int> g_netPool{-1};

bool writable(const std::string& dir, int& errOut) {
    errOut = 0;
    struct stat st{};
    if (::stat(dir.c_str(), &st) != 0) {
        if (::mkdir(dir.c_str(), 0777) != 0) {
            errOut = errno;
            return false;
        }
    } else {
        ::chmod(dir.c_str(), 0777);
    }
    std::string probe = dir + "/.write-test";
    if (!writeFileAtomic(probe, "ok")) {
        errOut = errno;
        return false;
    }
    ::unlink(probe.c_str());
    return true;
}

void migrateLegacy() {
    const std::string data = kDataDir, legacy = kLegacyDir, done = data + "/.migrated";
    std::string text;
    if (readFile(done, text)) return;
    int moved = 0;
    for (const char* name : {"account.json", "settings.json", "library.json", "library_cache.json", "prices.json"}) {
        std::string mine;
        if (readFile(legacy + "/" + name, text) && !readFile(data + "/" + name, mine) &&
            writeFileAtomic(data + "/" + name, text))
            ++moved;
    }
    if (readFile(data + "/account.json", text)) ::unlink((legacy + "/account.json").c_str());
    writeFileAtomic(done, "1\n");
    if (moved) g_dataNote = "moved " + std::to_string(moved) + " file(s) from " + legacy + " to " + data;
}

}  // namespace

bool init() {
    sceSysmoduleLoadModuleInternal(0x8000001C); // NET
    sceSysmoduleLoadModuleInternal(0x80000009); // NETCTL
    sceSysmoduleLoadModule(0x00BA);             // RANDOM

    int errPsbox = 0;
    int errLegacy = 0;
    if (writable(kDataDir, errPsbox)) {
        g_dataDirWritable = true;
        migrateLegacy();
    } else if (writable(kLegacyDir, errLegacy)) {
        g_dataDirWritable = true;
        g_dataDir = kLegacyDir;
        g_dataNote = std::string(kDataDir) + " not writable (errno " + std::to_string(errPsbox) + "); using " + kLegacyDir;
    } else {
        bool found = false;
        for (const char* fb : {"/download0/psbox", "/user/home/psbox", "/temp0/psbox"}) {
            int errFb = 0;
            if (writable(fb, errFb)) {
                g_dataDir = fb;
                g_dataDirWritable = true;
                g_dataNote = std::string("neither ") + kDataDir + " (errno " + std::to_string(errPsbox) +
                             ") nor " + kLegacyDir + " (errno " + std::to_string(errLegacy) +
                             ") writable; fallback to " + fb;
                found = true;
                break;
            }
        }
        if (!found) {
            g_dataDirErrno = errPsbox ? errPsbox : errLegacy;
            g_dataDirWritable = false;
            g_dataNote = std::string("neither ") + kDataDir + " (errno " + std::to_string(errPsbox) +
                         ") nor " + kLegacyDir + " (errno " + std::to_string(errLegacy) +
                         ") is writable: nothing will be kept";
        }
    }

    int rc = sceNetInit();
    if (rc < 0 && rc != static_cast<int>(0x80410101)) {
        XC_LOGW("sceNetInit: 0x%08x", static_cast<unsigned>(rc));
    }
    int ctlRc = sceNetCtlInit();
    if (ctlRc < 0 && ctlRc != static_cast<int>(0x80410101) && ctlRc != static_cast<int>(0x80412101)) {
        XC_LOGW("sceNetCtlInit: 0x%08x", static_cast<unsigned>(ctlRc));
    }
    int pool = sceNetPoolCreate("xcloud", 32 * 1024, 0);
    if (pool < 0) {
        XC_LOGE("sceNetPoolCreate: 0x%08x (host names will not resolve)", static_cast<unsigned>(pool));
    }
    g_netPool = pool;
    return true;
}

void shutdown() {
    sceNetCtlTerm();
}

std::string appDir() { return "/app0"; }
std::string dataDir() { return g_dataDir; }
std::string dataDirNote() { return g_dataNote; }
bool dataDirWritable() { return g_dataDirWritable; }
int dataDirErrno() { return g_dataDirErrno; }
std::string assetDir() { return "/app0/assets"; }
std::string caBundlePath() { return "/app0/assets/cacert.pem"; }

bool randomBytes(void* out, size_t len) {
    arc4random_buf(out, len);
    return true;
}

bool resolveIPv4(const std::string& host, std::vector<uint32_t>& addrs, std::string& err) {
    in_addr literal{};
    if (::inet_pton(AF_INET, host.c_str(), &literal) == 1) {
        addrs.push_back(literal.s_addr);
        return true;
    }
    int pool = g_netPool.load();
    if (pool < 0) {
        err = "DNS lookup failed for " + host + ": networking not initialised";
        return false;
    }
    int rid = sceNetResolverCreate("xcloud", pool, 0);
    if (rid < 0) {
        char buf[64];
        std::snprintf(buf, sizeof buf, "sceNetResolverCreate 0x%08x", static_cast<unsigned>(rid));
        err = "DNS lookup failed for " + host + ": " + buf;
        return false;
    }
    SceNetResolverInfo info{};
    int rc = sceNetResolverStartNtoaMultipleRecords(rid, host.c_str(), &info, 5000000, 2, 0);
    if (rc >= 0) {
        uint32_t count = std::min<uint32_t>(info.records, 10);
        for (uint32_t i = 0; i < count; ++i) {
            if (info.addrs[i].af == AF_INET && info.addrs[i].u.addr.s_addr != 0) {
                uint32_t a = info.addrs[i].u.addr.s_addr;
                if (std::find(addrs.begin(), addrs.end(), a) == addrs.end()) {
                    addrs.push_back(a);
                }
            }
        }
    }
    if (addrs.empty()) {
        uint32_t a = 0;
        rc = sceNetResolverStartNtoa(rid, host.c_str(), &a, 5000000, 2, 0);
        if (rc >= 0 && a != 0) {
            addrs.push_back(a);
        }
    }
    sceNetResolverDestroy(rid);
    if (addrs.empty()) {
        char buf[64];
        std::snprintf(buf, sizeof buf, "0x%08x", static_cast<unsigned>(rc));
        err = "DNS lookup failed for " + host + " (" + buf + ")";
        return false;
    }
    return true;
}

bool resolveIPv4(const std::string& host, uint32_t& addr, std::string& err) {
    std::vector<uint32_t> addrs;
    if (!resolveIPv4(host, addrs, err)) return false;
    addr = addrs[0];
    return true;
}

void probeNetworking() {}


bool restartApp() {
    char* argv[] = {nullptr};
    int rc = sceSystemServiceLoadExec("/app0/eboot.bin", argv);
    XC_LOGE("restart: sceSystemServiceLoadExec returned 0x%08x", static_cast<unsigned>(rc));
    return false;
}

std::string firmwareVersion() {
    SceKernelSwVersion v{};
    v.size = sizeof v;
    if (sceKernelGetSystemSwVersion(&v) != 0) return {};
    v.versionString[sizeof v.versionString - 1] = 0;
    std::string s = v.versionString;
    while (!s.empty() && s.front() == ' ') s.erase(0, 1);
    return s;
}

std::string platformName() {
    return "PlayStation 4";
}

size_t imageCacheBudget() {
    return 48u << 20;
}

std::string diagnostics() {
    size_t flex = 0;
    sceKernelAvailableFlexibleMemorySize(&flex);
    off_t start = 0;
    size_t direct = 0;
    sceKernelAvailableDirectMemorySize(0, static_cast<off_t>(sceKernelGetDirectMemorySize()), 16384, &start, &direct);
    char text[192];
    std::snprintf(text, sizeof text, "%s, flexible %zu MB free, direct %zu MB free (largest block), threads %d live / %d created",
                  sceKernelIsNeoMode() ? "PS4 Pro" : "PS4", flex >> 20, direct >> 20,
                  s_threadsLive.load(), s_threadsCreated.load());
    return text;
}

void makePrivate(const std::string&) {}

void notify(const std::string& text) { notify(text, text); }

void notify(const std::string& text, const std::string& forLog) {
    XC_LOGI("NOTIFY: %s", forLog.c_str());
    if (toastsEnabled() && forLog != "signed in (notification)") toasts().push(text, nowMs());
    struct NotificationRequest {
        uint8_t reserved[45];
        char message[3075];
    } req{};
    std::snprintf(req.message, sizeof req.message, "%s", text.c_str());
    sceKernelSendNotificationRequest(0, &req, sizeof req, 0);
}

void setNoThreadPinning(bool) {}
bool isHandheld() { return false; }
void forceHandheld(bool) {}

void setThreadAffinity(ThreadRole role, const char* name) {
    if (name && *name) {
        pthread_set_name_np(pthread_self(), name);
    }
    static std::once_flag s_maskOnce;
    static int s_allowedCpus[32];
    static int s_numAllowedCpus = 0;

    std::call_once(s_maskOnce, [&]() {
        cpu_set_t procMask;
        CPU_ZERO(&procMask);
        int grc = pthread_getaffinity_np(pthread_self(), sizeof(cpu_set_t), &procMask);
        if (grc == 0) {
            for (int i = 0; i < 32; ++i) {
                if (CPU_ISSET(i, &procMask)) {
                    s_allowedCpus[s_numAllowedCpus++] = i;
                }
            }
        }
        // Fallback to 6 Jaguar cores (mask 0x3F: cores 0..5) on PS4 if not detected
        if (s_numAllowedCpus < 2) {
            s_numAllowedCpus = 0;
            for (int i = 0; i < 6; ++i) {
                s_allowedCpus[s_numAllowedCpus++] = i;
            }
        }
        XC_LOGI("ps4 cpuset: %d allowed cpus detected (grc=%d)", s_numAllowedCpus, grc);
        for (int i = 0; i < s_numAllowedCpus; ++i) {
            XC_LOGI("  cpu slot %d: logical core %d", i, s_allowedCpus[i]);
        }
    });

    if (s_numAllowedCpus <= 1) {
        return;
    }

    // Every thread may run on every core of the title, at the default priority (700); only
    // the background catalogue tasks go lower. Pinning roles to single cores and raising the
    // display threads to 650 (and audio to 256) starved the network and worker threads at
    // 1080p: the stream froze about a second after the first frame (#301, #317). XCloud4,
    // which streams 1080p on PS4, pins nothing either. Threads inherit their creator's mask,
    // so every role gets the full mask explicitly.
    uint64_t orbisMask = 0;
    for (int s = 0; s < s_numAllowedCpus; ++s) {
        int idx = s_allowedCpus[s];
        if (idx >= 0 && idx < 64) {
            orbisMask |= (UINT64_C(1) << idx);
        }
    }

    const bool isBgTask = role == ThreadRole::Worker && name &&
                          (std::strcmp(name, "xcloud_img") == 0 || std::strcmp(name, "xcloud_hydr") == 0 ||
                           std::strcmp(name, "xcloud_price") == 0 || std::strcmp(name, "xcloud_upd") == 0 ||
                           std::strcmp(name, "xcloud_web") == 0);
    const int targetPrio = isBgTask ? 740 : 700;

    int rc = scePthreadSetaffinity(scePthreadSelf(), orbisMask);
    if (rc != 0) {
        XC_LOGW("scePthreadSetaffinity(%s, 0x%llx): 0x%08x", name ? name : "thread",
                static_cast<unsigned long long>(orbisMask), static_cast<unsigned>(rc));
    } else {
        XC_LOGI("thread %s pinned to role %d (mask 0x%llx)", name ? name : "unknown",
                static_cast<int>(role), static_cast<unsigned long long>(orbisMask));
    }
    scePthreadSetprio(scePthreadSelf(), targetPrio);
}

// No realtime priority on PS4: the three audio threads at 256 shared a core with the
// network and input threads and starved them. They stay at the default priority, as in
// XCloud4; the audio queue absorbs the scheduling jitter.
void setThreadRealtimePriority() {}

}  // namespace xc::platform

extern "C" int xc_resolve_ipv4(const char* host, uint32_t* addr) {
    std::string err;
    if (xc::platform::resolveIPv4(host, *addr, err)) return 0;
    XC_LOGW("%s", err.c_str());
    return -1;
}

// IPv4-only getaddrinfo. The OpenOrbis musl version fails on PS4 even for
// numeric literals, which kept every remote ICE candidate unresolved.
namespace {
struct Ps4AddrInfo {
    struct addrinfo ai;
    struct sockaddr_in sin;
};
}  // namespace

extern "C" int getaddrinfo(const char* node, const char* service, const struct addrinfo* hints,
                           struct addrinfo** res) {
    if (!res) return EAI_FAIL;
    *res = nullptr;
    if (!node && !service) return EAI_NONAME;
    const int family = hints ? hints->ai_family : AF_UNSPEC;
    const int flags = hints ? hints->ai_flags : 0;
    if (family != AF_UNSPEC && family != AF_INET) return EAI_FAMILY;

    uint16_t port = 0;
    if (service && *service) {
        char* end = nullptr;
        unsigned long p = std::strtoul(service, &end, 10);
        if (!end || *end != '\0' || p > 65535) return EAI_SERVICE;
        port = static_cast<uint16_t>(p);
    }

    in_addr addr{};
    if (!node) {
        addr.s_addr = (flags & AI_PASSIVE) ? htonl(INADDR_ANY) : htonl(INADDR_LOOPBACK);
    } else if (::inet_pton(AF_INET, node, &addr) != 1) {
        in6_addr v6{};
        if (::inet_pton(AF_INET6, node, &v6) == 1) return EAI_FAMILY;  // no IPv6 on PS4
        if (flags & AI_NUMERICHOST) return EAI_NONAME;
        if (std::strcmp(node, "localhost") == 0) {
            addr.s_addr = htonl(INADDR_LOOPBACK);
        } else {
            uint32_t a = 0;
            if (xc_resolve_ipv4(node, &a) != 0) return EAI_NONAME;
            addr.s_addr = a;
        }
    }

    auto* r = static_cast<Ps4AddrInfo*>(std::calloc(1, sizeof(Ps4AddrInfo)));
    if (!r) return EAI_MEMORY;
    r->sin.sin_len = sizeof(struct sockaddr_in);
    r->sin.sin_family = AF_INET;
    r->sin.sin_port = htons(port);
    r->sin.sin_addr = addr;
    r->ai.ai_flags = flags;
    r->ai.ai_family = AF_INET;
    r->ai.ai_socktype = hints && hints->ai_socktype ? hints->ai_socktype : SOCK_STREAM;
    r->ai.ai_protocol = hints ? hints->ai_protocol : 0;
    r->ai.ai_addrlen = sizeof(struct sockaddr_in);
    r->ai.ai_addr = reinterpret_cast<struct sockaddr*>(&r->sin);
    r->ai.ai_canonname = nullptr;
    r->ai.ai_next = nullptr;
    *res = &r->ai;
    return 0;
}

extern "C" void freeaddrinfo(struct addrinfo* ai) {
    while (ai) {
        struct addrinfo* next = ai->ai_next;
        std::free(ai);  // ai is the first member of Ps4AddrInfo
        ai = next;
    }
}