starred/AnyPS5
1
0 Fork 0
mirror of https://github.com/boykopovar/AnyPS5.git synced 2026-10-22 00:22:57 -05:00
Code Issues Packages Projects Releases 3 Wiki Activity
Files
f89c7fb883f2a8f910275da636c9c0cda02be6ae
AnyPS5/core/libs/prx/libSceNet/Export.cpp
T
David 3d64981643 feat(libSceNet): implement sceNetResolverAbort and sceNetResolverStartNtoaMultipleRecords 
UFC 6 (PPSA23566) imports sceNetResolverAbort (#992, #1502); Palworld
(PPSA23126) and LEGO Horizon Adventures (PPSA14632) import
sceNetResolverStartNtoaMultipleRecords.

Signatures and behaviour follow shadPS4 811bfcd7d17e
(src/core/libraries/net/net.cpp, net_resolver.cpp); the abort signature
also matches SharpProspero Interop/Net/Socket.cs.

sceNetResolverStartNtoaMultipleRecords shares the lookup of the Ex form
and, like it, throws for any flag. sceNetResolverAbort returns EBADF for
an unknown resolver and throws for flag bits other than NTOA (1) and
ATON (2) preservation. Host lookups cannot be interrupted, so an abort
during a running lookup makes it fail with EINTR when the host call
returns, without writing its output; with nothing running, the
preservation flags make the next lookup of that kind fail with EINTR.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
(cherry picked from commit bcc8be8a58aa6a9e6b7c288d8a90af6ed63837aa)
2026-10-12 22:03:56 +02:00

1419 lines
52 KiB
C++
Raw Blame History

#ifdef _WIN32
#define WIN32_LEAN_AND_MEAN
#include <winsock2.h>
#include <ws2tcpip.h>
#include <windows.h>
#else
#include <arpa/inet.h>
#include <cerrno>
#include <fcntl.h>
#include <netdb.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <poll.h>
#include <unistd.h>
#endif
#include <algorithm>
#include <atomic>
#include <climits>
#include <chrono>
#include <condition_variable>
#include <cstdint>
#include <cstdio>
#include <cstddef>
#include <cstring>
#include <memory>
#include <map>
#include <mutex>
#include <new>
#include <vector>
#include <set>
#include <stdexcept>
#include <string>
#include <utility>
#include "SceTypes.hpp"
#include "prx/libc/include/General.hpp"
#include "prx/libc/include/GuestArena.hpp"
#include "prx/libkernel/Socket/include/SocketPoll.hpp"
// Guest socket descriptors retain PS5 semantics while their transport is backed by host sockets.
namespace {
// FreeBSD errno numbers as reported through sceNetErrnoLoc (SCE_NET_ERROR_* is 0x80410100 + errno).
constexpr int NET_ENOENT = 2;
constexpr int NET_EINTR = 4;
constexpr int NET_EBADF = 9;
constexpr int NET_EACCES = 13;
constexpr int NET_EFAULT = 14;
constexpr int NET_EINVAL = 22;
constexpr int NET_ENOSPC = 28;
constexpr int NET_EDOM = 33;
constexpr int NET_EAGAIN = 35;
constexpr int NET_EINPROGRESS = 36;
constexpr int NET_EALREADY = 37;
constexpr int NET_ENOTSOCK = 38;
constexpr int NET_EOPNOTSUPP = 45;
constexpr int NET_EPROTONOSUPPORT = 43;
constexpr int NET_EAFNOSUPPORT = 47;
constexpr int NET_EADDRINUSE = 48;
constexpr int NET_EADDRNOTAVAIL = 49;
constexpr int NET_ENETUNREACH = 51;
constexpr int NET_ECONNABORTED = 53;
constexpr int NET_ENOBUFS = 55;
constexpr int NET_EISCONN = 56;
constexpr int NET_ENOTCONN = 57;
constexpr int NET_EMSGSIZE = 40;
constexpr int NET_ETIMEDOUT = 60;
constexpr int NET_ECONNREFUSED = 61;
constexpr int NET_EHOSTUNREACH = 65;
constexpr int NET_ERROR_BASE = static_cast<int>(0x80410100u);
constexpr int NET_ERROR_RESOLVER_ENODNS = static_cast<int>(0x804101E1u);
constexpr int NET_RESOLVER_ABORT_FLAG_NTOA_PRESERVATION = 0x1;
constexpr int NET_RESOLVER_ABORT_FLAG_ATON_PRESERVATION = 0x2;
constexpr int NET_AF_INET = 2;
constexpr int NET_AF_INET6 = 28;
constexpr int NET_SOCK_STREAM = 1;
constexpr int NET_SOCK_DGRAM = 2;
constexpr int NET_SOCK_RAW = 3;
constexpr int NET_EPOLL_CTL_ADD = 1;
constexpr int NET_EPOLL_CTL_MOD = 2;
constexpr int NET_EPOLL_CTL_DEL = 3;
constexpr int NET_SOL_SOCKET = 0xFFFF;
constexpr int NET_SO_SNDTIMEO = 0x1005;
constexpr int NET_SO_RCVTIMEO = 0x1006;
constexpr int NET_SO_NBIO = 0x1200;
constexpr int NET_SO_REUSEADDR = 0x4;
constexpr int NET_SO_BROADCAST = 0x20;
constexpr int NET_SO_SNDBUF = 0x1001;
constexpr int NET_SO_RCVBUF = 0x1002;
constexpr int NET_MSG_PEEK = 0x2;
constexpr int NET_MSG_TRUNC = 0x10;
constexpr int NET_UIO_MAXIOV = 1024;
#ifdef _WIN32
using NativeSocket = SOCKET;
using NativeLength = int;
constexpr NativeSocket INVALID_NATIVE_SOCKET = INVALID_SOCKET;
constexpr int NATIVE_SEND_FLAGS = 0;
bool initialize_sockets() {
static const int result = [] {
WSADATA data{};
return WSAStartup(MAKEWORD(2, 2), &data);
}();
return result == 0;
}
void close_socket(NativeSocket socket) { closesocket(socket); }
int native_error() {
switch (WSAGetLastError()) {
case WSAEWOULDBLOCK: return NET_EAGAIN;
case WSAEINPROGRESS: return NET_EINPROGRESS;
case WSAEALREADY: return NET_EALREADY;
case WSAEADDRINUSE: return NET_EADDRINUSE;
case WSAEADDRNOTAVAIL: return NET_EADDRNOTAVAIL;
case WSAEAFNOSUPPORT: return NET_EAFNOSUPPORT;
case WSAENETUNREACH: return NET_ENETUNREACH;
case WSAEHOSTUNREACH: return NET_EHOSTUNREACH;
case WSAECONNABORTED: return NET_ECONNABORTED;
case WSAENOBUFS: return NET_ENOBUFS;
case WSAEISCONN: return NET_EISCONN;
case WSAENOTCONN: return NET_ENOTCONN;
case WSAEACCES: return NET_EACCES;
case WSAECONNRESET: return 54;
case WSAETIMEDOUT: return NET_ETIMEDOUT;
case WSAECONNREFUSED: return NET_ECONNREFUSED;
case WSAEMSGSIZE: return NET_EMSGSIZE;
case WSAEINTR: return 4;
case WSAEINVAL: return NET_EINVAL;
case WSAENOTSOCK: return NET_ENOTSOCK;
case WSAESHUTDOWN: return 32;
default: return 5;
}
}
#else
using NativeSocket = int;
using NativeLength = socklen_t;
constexpr NativeSocket INVALID_NATIVE_SOCKET = -1;
constexpr int NATIVE_SEND_FLAGS = MSG_NOSIGNAL;
bool initialize_sockets() { return true; }
void close_socket(NativeSocket socket) { ::close(socket); }
int native_error() {
switch (errno) {
case EAGAIN: return NET_EAGAIN;
#if EWOULDBLOCK != EAGAIN
case EWOULDBLOCK: return NET_EAGAIN;
#endif
case EINPROGRESS: return NET_EINPROGRESS;
case EALREADY: return NET_EALREADY;
case EADDRINUSE: return NET_EADDRINUSE;
case EADDRNOTAVAIL: return NET_EADDRNOTAVAIL;
case EAFNOSUPPORT: return NET_EAFNOSUPPORT;
case ENETUNREACH: return NET_ENETUNREACH;
case EHOSTUNREACH: return NET_EHOSTUNREACH;
case ECONNABORTED: return NET_ECONNABORTED;
case ENOBUFS: return NET_ENOBUFS;
case EISCONN: return NET_EISCONN;
case ENOTCONN: return NET_ENOTCONN;
case EACCES: return NET_EACCES;
case ECONNRESET: return 54;
case ETIMEDOUT: return NET_ETIMEDOUT;
case ECONNREFUSED: return NET_ECONNREFUSED;
case EMSGSIZE: return NET_EMSGSIZE;
case EINTR: return 4;
case EINVAL: return NET_EINVAL;
case ENOTSOCK: return NET_ENOTSOCK;
case EPIPE: return 32;
default: return 5;
}
}
#endif
struct NativeSocketHandle {
NativeSocket value;
explicit NativeSocketHandle(NativeSocket socket) : value(socket) {}
~NativeSocketHandle() {
if (value != INVALID_NATIVE_SOCKET) close_socket(value);
}
};
bool guest_to_native_address(const void* address, std::uint32_t length,
sockaddr_storage& native, NativeLength& native_length) {
if (!address || length < 2) return false;
const auto* bytes = static_cast<const std::uint8_t*>(address);
if (bytes[1] == NET_AF_INET && length >= 16) {
auto& v4 = reinterpret_cast<sockaddr_in&>(native);
v4.sin_family = AF_INET;
std::memcpy(&v4.sin_port, bytes + 2, 2);
std::memcpy(&v4.sin_addr, bytes + 4, 4);
native_length = sizeof(v4);
return true;
}
if (bytes[1] == NET_AF_INET6 && length >= 28) {
auto& v6 = reinterpret_cast<sockaddr_in6&>(native);
v6.sin6_family = AF_INET6;
std::memcpy(&v6.sin6_port, bytes + 2, 2);
std::memcpy(&v6.sin6_flowinfo, bytes + 4, 4);
std::memcpy(&v6.sin6_addr, bytes + 8, 16);
std::memcpy(&v6.sin6_scope_id, bytes + 24, 4);
native_length = sizeof(v6);
return true;
}
return false;
}
bool native_to_guest_address(const sockaddr_storage& native, void* address, std::uint32_t* length) {
if (!address || !length) return false;
if (native.ss_family == AF_UNSPEC) {
*length = 0;
return true;
}
std::uint8_t bytes[28]{};
if (native.ss_family == AF_INET) {
const auto& v4 = reinterpret_cast<const sockaddr_in&>(native);
bytes[0] = 16;
bytes[1] = NET_AF_INET;
std::memcpy(bytes + 2, &v4.sin_port, 2);
std::memcpy(bytes + 4, &v4.sin_addr, 4);
} else if (native.ss_family == AF_INET6) {
const auto& v6 = reinterpret_cast<const sockaddr_in6&>(native);
bytes[0] = 28;
bytes[1] = NET_AF_INET6;
std::memcpy(bytes + 2, &v6.sin6_port, 2);
std::memcpy(bytes + 4, &v6.sin6_flowinfo, 4);
std::memcpy(bytes + 8, &v6.sin6_addr, 16);
std::memcpy(bytes + 24, &v6.sin6_scope_id, 4);
} else {
return false;
}
const auto required = static_cast<std::uint32_t>(bytes[0]);
std::memcpy(address, bytes, std::min(*length, required));
*length = required;
return true;
}
struct Sock {
int family = 0;
int type = 0;
std::shared_ptr<NativeSocketHandle> native;
bool nonblock = false;
bool bound = false;
bool listening = false;
bool aborted = false;
int rcv_timeout_us = 0;
int snd_timeout_us = 0;
};
#ifdef _WIN32
struct HostMutex {
SRWLOCK native = SRWLOCK_INIT;
HostMutex() = default;
HostMutex(const HostMutex&) = delete;
HostMutex& operator=(const HostMutex&) = delete;
void lock() { AcquireSRWLockExclusive(&native); }
void unlock() { ReleaseSRWLockExclusive(&native); }
};
#else
using HostMutex = std::mutex;
#endif
class HostCondition {
public:
HostCondition() = default;
HostCondition(const HostCondition&) = delete;
HostCondition& operator=(const HostCondition&) = delete;
void NotifyAll() {
#ifdef _WIN32
WakeAllConditionVariable(&native);
#else
native.notify_all();
#endif
}
void WaitUntil(std::unique_lock<HostMutex>& lock, std::chrono::steady_clock::time_point deadline) {
#ifdef _WIN32
const auto now = std::chrono::steady_clock::now();
if (deadline <= now) return;
const auto milliseconds = std::chrono::ceil<std::chrono::milliseconds>(deadline - now).count();
if (!SleepConditionVariableSRW(&native, &lock.mutex()->native, static_cast<DWORD>(milliseconds), 0) &&
GetLastError() != ERROR_TIMEOUT)
throw std::runtime_error("sceNetEpollWait: native condition wait failed");
#else
native.wait_until(lock, deadline);
#endif
}
private:
#ifdef _WIN32
CONDITION_VARIABLE native = CONDITION_VARIABLE_INIT;
#else
std::condition_variable native;
#endif
};
HostMutex g_mutex;
HostCondition g_cv;
std::map<int, Sock> g_socks;
std::set<int> g_epolls;
std::map<int, std::map<int, NetEpollEvent>> g_epoll_socks;
std::set<int> g_epoll_aborted;
std::map<int, std::size_t> g_pools;
struct NetMemoryPoolStats {
std::size_t pool_size;
std::size_t max_inuse_size;
std::size_t current_inuse_size;
};
struct Resolver {
int error = 0;
int running = 0;
std::uint64_t aborts = 0;
bool abort_ntoa = false;
bool abort_aton = false;
};
std::map<int, Resolver> g_resolvers;
int g_next_sock = 32;
int g_next_epoll = 0x4000;
int g_next_pool = 1;
int g_next_resolver = 0x100;
bool g_net_inited = false;
int* errno_slot() {
static thread_local int e = 0;
return &e;
}
extern "C" int* APS5_VABI __error_nid_postfix();
void set_errno(int err) {
*errno_slot() = err;
*__error_nid_postfix() = err;
}
int fail(int err) {
set_errno(err);
return NET_ERROR_BASE | err;
}
int set_native_timeout(NativeSocket native, int optname, std::int64_t microseconds) {
const int native_option = optname == NET_SO_RCVTIMEO ? SO_RCVTIMEO : SO_SNDTIMEO;
#ifdef _WIN32
const std::int64_t milliseconds = (microseconds + 999) / 1000;
const DWORD timeout_ms = milliseconds > static_cast<std::int64_t>(MAXDWORD) ? MAXDWORD : static_cast<DWORD>(milliseconds);
return ::setsockopt(native, SOL_SOCKET, native_option, reinterpret_cast<const char*>(&timeout_ms), sizeof(timeout_ms));
#else
timeval timeout{};
timeout.tv_sec = static_cast<time_t>(microseconds / 1000000);
timeout.tv_usec = static_cast<suseconds_t>(microseconds % 1000000);
return ::setsockopt(native, SOL_SOCKET, native_option, &timeout, sizeof(timeout));
#endif
}
int set_kernel_timeout(int descriptor, int optname, const void* value, std::uint32_t length) {
KernelTimeval timeout{};
if (value == nullptr && length != 0) return NET_EFAULT;
if (length < sizeof(timeout)) return NET_EINVAL;
std::memcpy(&timeout, value, sizeof(timeout));
if (timeout.tv_sec < 0 || timeout.tv_usec < 0 || timeout.tv_usec >= 1000000) return NET_EDOM;
const std::int64_t microseconds = std::min<std::int64_t>(timeout.tv_sec, INT32_MAX) * 1000000 + timeout.tv_usec;
Sock socket;
{
std::lock_guard lk(g_mutex);
const auto it = g_socks.find(descriptor);
if (it == g_socks.end()) return NET_EBADF;
socket = it->second;
}
if (set_native_timeout(socket.native->value, optname, microseconds) != 0) return native_error();
std::lock_guard lk(g_mutex);
const auto it = g_socks.find(descriptor);
if (it != g_socks.end()) {
const int stored = static_cast<int>(std::min<std::int64_t>(microseconds, INT_MAX));
if (optname == NET_SO_RCVTIMEO) it->second.rcv_timeout_us = stored;
else it->second.snd_timeout_us = stored;
}
return 0;
}
int begin_lookup(int rid, bool Resolver::*preservedAbort, std::uint64_t& generation) {
std::lock_guard lk(g_mutex);
const auto resolver = g_resolvers.find(rid);
if (resolver == g_resolvers.end()) return fail(NET_EBADF);
if (std::exchange(resolver->second.*preservedAbort, false)) {
resolver->second.error = NET_ERROR_BASE | NET_EINTR;
return fail(NET_EINTR);
}
++resolver->second.running;
generation = resolver->second.aborts;
return 0;
}
int end_lookup(int rid, std::uint64_t generation, int error) {
std::lock_guard lk(g_mutex);
const auto resolver = g_resolvers.find(rid);
if (resolver == g_resolvers.end()) return error;
--resolver->second.running;
if (resolver->second.aborts != generation) error = fail(NET_EINTR);
resolver->second.error = error;
return error;
}
void log_soft(const char* func, const char* what) {
static std::mutex mtx;
static std::map<std::string, int> hits;
std::lock_guard<std::mutex> lk(mtx);
if (++hits[func] > 3) {
return;
}
std::fprintf(stderr, "[SOFT-NET] %s -> %s\n", func, what);
std::fflush(stderr);
}
std::uint16_t swap16(std::uint16_t v) { return static_cast<std::uint16_t>((v << 8) | (v >> 8)); }
std::uint32_t swap32(std::uint32_t v) {
return (v << 24) | ((v & 0xFF00u) << 8) | ((v >> 8) & 0xFF00u) | (v >> 24);
}
std::uint64_t swap64(std::uint64_t v) {
return (v << 56) | ((v & 0xFF00u) << 40) | ((v & 0xFF0000u) << 24) | ((v & 0xFF000000u) << 8) |
((v >> 8) & 0xFF000000u) | ((v >> 24) & 0xFF0000u) | ((v >> 40) & 0xFF00u) | (v >> 56);
}
struct NetIovec {
void* base;
std::uint64_t length;
};
struct NetMsghdr {
void* name;
std::uint32_t name_length;
NetIovec* iov;
int iov_length;
void* control;
std::uint32_t control_length;
int flags;
};
static_assert(sizeof(NetMsghdr) == 48 && offsetof(NetMsghdr, iov) == 16 && offsetof(NetMsghdr, control) == 32 &&
offsetof(NetMsghdr, flags) == 44);
std::int64_t message_length(const NetMsghdr* message) {
if (!message) return fail(NET_EFAULT);
if (message->iov_length < 0 || message->iov_length > NET_UIO_MAXIOV) return fail(NET_EMSGSIZE);
if (message->iov_length && !message->iov) return fail(NET_EFAULT);
std::uint64_t total = 0;
for (int i = 0; i < message->iov_length; ++i) {
const auto& entry = message->iov[i];
if (!entry.base && entry.length) return fail(NET_EFAULT);
if (entry.length > INT_MAX - total) return fail(NET_EINVAL);
total += entry.length;
}
return static_cast<std::int64_t>(total);
}
int receive_error(const Sock& socket) {
#ifdef _WIN32
if (WSAGetLastError() == WSAETIMEDOUT && socket.type != NET_SOCK_STREAM && socket.rcv_timeout_us > 0) return NET_EAGAIN;
#else
(void)socket;
#endif
return native_error();
}
} // namespace
extern "C" {
extern const std::uint32_t sce_net_in6addr_any[4] = {};
alignas(std::uint32_t) extern const std::uint8_t sce_net_in6addr_linklocal_allnodes[16] = {0xff, 0x02, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1};
int* APS5_VABI sceNetErrnoLoc(void) {
return errno_slot();
}
int APS5_VABI sceNetShowNetstat(void) {
NotImplemented_nid_no_patch(__func__);
return 0;
}
int PollSockets(KernelSocketPoll::Entry* entries, int count, int timeoutMilliseconds) {
std::vector<std::shared_ptr<NativeSocketHandle>> natives(static_cast<std::size_t>(count));
{
std::lock_guard lk(g_mutex);
for (int index = 0; index < count; ++index) {
const auto socket = g_socks.find(entries[index].descriptor);
if (socket != g_socks.end()) natives[static_cast<std::size_t>(index)] = socket->second.native;
}
}
#ifdef _WIN32
std::vector<WSAPOLLFD> descriptors;
constexpr short NativeReadable = POLLRDNORM;
constexpr short NativeUrgent = POLLRDBAND;
constexpr short NativeWritable = POLLWRNORM;
#else
std::vector<pollfd> descriptors;
constexpr short NativeReadable = POLLIN;
constexpr short NativeUrgent = POLLPRI;
constexpr short NativeWritable = POLLOUT;
#endif
std::vector<int> owners;
for (int index = 0; index < count; ++index) {
auto& entry = entries[index];
if (!natives[static_cast<std::size_t>(index)]) {
entry.revents = KernelSocketPoll::Unknown;
continue;
}
decltype(descriptors)::value_type descriptor{};
descriptor.fd = natives[static_cast<std::size_t>(index)]->value;
if (entry.events & KernelSocketPoll::Readable) descriptor.events |= NativeReadable;
if (entry.events & KernelSocketPoll::Urgent) descriptor.events |= NativeUrgent;
if (entry.events & KernelSocketPoll::Writable) descriptor.events |= NativeWritable;
descriptors.push_back(descriptor);
owners.push_back(index);
}
if (descriptors.empty()) return 0;
#ifdef _WIN32
const int result = WSAPoll(descriptors.data(), static_cast<ULONG>(descriptors.size()), timeoutMilliseconds);
#else
const int result = ::poll(descriptors.data(), descriptors.size(), timeoutMilliseconds);
#endif
if (result < 0) return -native_error();
int ready = 0;
for (std::size_t index = 0; index < descriptors.size(); ++index) {
const short native = descriptors[index].revents;
short revents = 0;
if (native & NativeReadable) revents |= KernelSocketPoll::Readable;
if (native & NativeUrgent) revents |= KernelSocketPoll::Urgent;
if (native & NativeWritable) revents |= KernelSocketPoll::Writable;
if (native & (POLLERR | POLLNVAL)) revents |= KernelSocketPoll::Error;
if (native & POLLHUP) revents |= KernelSocketPoll::HangUp;
entries[owners[index]].revents = revents;
if (revents != 0) ++ready;
}
return ready;
}
const bool g_socketPollerRegistered = (KernelSetSocketPoller_nid_no_patch(&PollSockets), true);
extern "C" int APS5_VABI sceNetSocketClose(int s);
bool CloseSocketForKernel(int descriptor, int* error) {
{
std::lock_guard lk(g_mutex);
if (g_socks.count(descriptor) == 0) return false;
}
*error = sceNetSocketClose(descriptor) == 0 ? 0 : *errno_slot();
return true;
}
const bool g_socketCloserRegistered = (KernelSetSocketCloser_nid_no_patch(&CloseSocketForKernel), true);
extern "C" int APS5_VABI sceNetSetsockopt(int s, int level, int optname, const void* optval, uint32_t optlen);
bool SetSocketOptionForKernel(int descriptor, int level, int option, const void* value, std::uint32_t length, int* error) {
{
std::lock_guard lk(g_mutex);
if (g_socks.count(descriptor) == 0) return false;
}
if (level == NET_SOL_SOCKET && (option == NET_SO_RCVTIMEO || option == NET_SO_SNDTIMEO)) {
*error = set_kernel_timeout(descriptor, option, value, length);
if (*error != 0) set_errno(*error);
return true;
}
*error = sceNetSetsockopt(descriptor, level, option, value, length) == 0 ? 0 : *errno_slot();
return true;
}
const bool g_socketOptionSetterRegistered = (KernelSetSocketOptionSetter_nid_no_patch(&SetSocketOptionForKernel), true);
int APS5_VABI sceNetInit_nid_postfix(void) {
std::lock_guard lk(g_mutex);
g_net_inited = true;
return 0;
}
int APS5_VABI sceNetTerm(void) {
std::lock_guard lk(g_mutex);
g_net_inited = false;
return 0;
}
int APS5_VABI sceNetPoolCreate(const char* name, int size, int flags) {
(void)name;
(void)flags;
if (size <= 0) {
return fail(NET_EINVAL);
}
std::lock_guard lk(g_mutex);
const int id = g_next_pool++;
g_pools.emplace(id, static_cast<std::size_t>(size));
return id;
}
int APS5_VABI sceNetPoolDestroy(int memid) {
std::lock_guard lk(g_mutex);
return g_pools.erase(memid) != 0 ? 0 : fail(NET_EBADF);
}
int APS5_VABI sceNetSocket(const char* name, int family, int type, int protocol) {
(void)name;
if (family != NET_AF_INET && family != NET_AF_INET6) {
return fail(NET_EAFNOSUPPORT);
}
if (type != NET_SOCK_STREAM && type != NET_SOCK_DGRAM && type != NET_SOCK_RAW) {
return fail(NET_EPROTONOSUPPORT);
}
if (!initialize_sockets()) return fail(5);
const NativeSocket native = ::socket(family == NET_AF_INET ? AF_INET : AF_INET6, type, protocol);
if (native == INVALID_NATIVE_SOCKET) return fail(native_error());
const int ipv6_only = 1;
if (family == NET_AF_INET6 &&
::setsockopt(native, IPPROTO_IPV6, IPV6_V6ONLY, reinterpret_cast<const char*>(&ipv6_only), sizeof(ipv6_only)) != 0) {
const int error = native_error();
close_socket(native);
return fail(error);
}
std::shared_ptr<NativeSocketHandle> handle;
try {
handle = std::make_shared<NativeSocketHandle>(native);
} catch (const std::bad_alloc&) {
close_socket(native);
return fail(12);
}
std::lock_guard lk(g_mutex);
const int fd = g_next_sock++;
Sock s;
s.family = family;
s.type = type;
s.native = std::move(handle);
g_socks[fd] = s;
return fd;
}
int APS5_VABI sceNetSocketClose(int s) {
std::shared_ptr<NativeSocketHandle> native;
{
std::lock_guard lk(g_mutex);
const auto it = g_socks.find(s);
if (it == g_socks.end()) return fail(NET_EBADF);
native = it->second.native;
g_socks.erase(it);
}
if (native) {
#ifdef _WIN32
::shutdown(native->value, SD_BOTH);
#else
::shutdown(native->value, SHUT_RDWR);
#endif
}
g_cv.NotifyAll();
return 0;
}
int APS5_VABI sceNetSocketAbort(int s, int flags) {
(void)flags;
std::shared_ptr<NativeSocketHandle> native;
{
std::lock_guard lk(g_mutex);
auto it = g_socks.find(s);
if (it == g_socks.end()) return fail(NET_EBADF);
it->second.aborted = true;
native = it->second.native;
}
#ifdef _WIN32
if (native) ::shutdown(native->value, SD_BOTH);
#else
if (native) ::shutdown(native->value, SHUT_RDWR);
#endif
g_cv.NotifyAll();
return 0;
}
int APS5_VABI sceNetBind_nid_postfix(int s, const void* addr, uint32_t addrlen) {
Sock socket;
{
std::lock_guard lk(g_mutex);
auto it = g_socks.find(s);
if (it == g_socks.end()) return fail(NET_EBADF);
socket = it->second;
if (it->second.bound) return fail(NET_EINVAL);
}
sockaddr_storage native{};
NativeLength native_length = 0;
if (!guest_to_native_address(addr, addrlen, native, native_length)) return fail(NET_EINVAL);
if (native.ss_family != (socket.family == NET_AF_INET ? AF_INET : AF_INET6)) return fail(NET_EAFNOSUPPORT);
if (::bind(socket.native->value, reinterpret_cast<const sockaddr*>(&native), native_length) != 0)
return fail(native_error());
std::lock_guard lk(g_mutex);
auto it = g_socks.find(s);
if (it != g_socks.end()) it->second.bound = true;
return 0;
}
int APS5_VABI sceNetListen(int s, int backlog) {
Sock socket;
{
std::lock_guard lk(g_mutex);
auto it = g_socks.find(s);
if (it == g_socks.end()) return fail(NET_EBADF);
socket = it->second;
}
if (socket.type != NET_SOCK_STREAM) return fail(NET_EOPNOTSUPP);
if (::listen(socket.native->value, backlog) != 0) return fail(native_error());
std::lock_guard lk(g_mutex);
auto it = g_socks.find(s);
if (it != g_socks.end()) {
it->second.bound = true;
it->second.listening = true;
}
return 0;
}
int APS5_VABI sceNetAccept(int s, void* addr, uint32_t* addrlen) {
Sock listener;
{
std::lock_guard lk(g_mutex);
auto it = g_socks.find(s);
if (it == g_socks.end()) return fail(NET_EBADF);
listener = it->second;
}
if (!listener.listening) return fail(NET_EINVAL);
if (addr && !addrlen) return fail(NET_EINVAL);
sockaddr_storage peer{};
NativeLength peer_length = sizeof(peer);
const NativeSocket accepted = ::accept(listener.native->value,
addr ? reinterpret_cast<sockaddr*>(&peer) : nullptr, addr ? &peer_length : nullptr);
if (accepted == INVALID_NATIVE_SOCKET) return fail(native_error());
std::shared_ptr<NativeSocketHandle> handle;
try {
handle = std::make_shared<NativeSocketHandle>(accepted);
} catch (const std::bad_alloc&) {
close_socket(accepted);
return fail(12);
}
Sock connection;
connection.family = listener.family;
connection.type = NET_SOCK_STREAM;
connection.native = std::move(handle);
int descriptor;
{
std::lock_guard lk(g_mutex);
descriptor = g_next_sock++;
g_socks.emplace(descriptor, connection);
}
if (addr && !native_to_guest_address(peer, addr, addrlen)) {
sceNetSocketClose(descriptor);
return fail(NET_EAFNOSUPPORT);
}
return descriptor;
}
int APS5_VABI sceNetConnect(int s, const void* addr, uint32_t addrlen) {
Sock socket;
{
std::lock_guard lk(g_mutex);
auto it = g_socks.find(s);
if (it == g_socks.end()) return fail(NET_EBADF);
socket = it->second;
}
sockaddr_storage native{};
NativeLength native_length = 0;
if (!guest_to_native_address(addr, addrlen, native, native_length)) return fail(NET_EINVAL);
if (native.ss_family != (socket.family == NET_AF_INET ? AF_INET : AF_INET6)) return fail(NET_EAFNOSUPPORT);
if (::connect(socket.native->value, reinterpret_cast<const sockaddr*>(&native), native_length) == 0) return 0;
#ifdef _WIN32
if (WSAGetLastError() == WSAEWOULDBLOCK) return fail(NET_EINPROGRESS);
#endif
return fail(native_error());
}
int64_t APS5_VABI sceNetRecv(int s, void* buf, size_t len, int flags) {
if (flags != 0 && flags != 2) return fail(NET_EOPNOTSUPP);
if (!buf && len) return fail(NET_EINVAL);
if (len > INT_MAX) return fail(NET_EMSGSIZE);
Sock socket;
{
std::lock_guard lk(g_mutex);
auto it = g_socks.find(s);
if (it == g_socks.end()) return fail(NET_EBADF);
socket = it->second;
}
const GuestArena::HostWrite destination(len == 0 ? nullptr : buf, len);
if (!destination.Open()) return fail(NET_EFAULT);
const int native_flags = flags == 2 ? MSG_PEEK : 0;
const int result = ::recv(socket.native->value, static_cast<char*>(buf), static_cast<int>(len), native_flags);
#ifdef _WIN32
if (result < 0 && socket.type == NET_SOCK_DGRAM && WSAGetLastError() == WSAEMSGSIZE) return static_cast<int64_t>(len);
#endif
return result >= 0 ? result : fail(receive_error(socket));
}
int64_t APS5_VABI sceNetRecvfrom(int s, void* buf, size_t len, int flags, void* from, uint32_t* fromlen) {
if (flags != 0 && flags != 2) return fail(NET_EOPNOTSUPP);
if (!buf && len) return fail(NET_EINVAL);
if (len > INT_MAX) return fail(NET_EMSGSIZE);
if (from && !fromlen) return fail(NET_EINVAL);
Sock socket;
{
std::lock_guard lk(g_mutex);
auto it = g_socks.find(s);
if (it == g_socks.end()) return fail(NET_EBADF);
socket = it->second;
}
const GuestArena::HostWrite destination(len == 0 ? nullptr : buf, len);
if (!destination.Open()) return fail(NET_EFAULT);
sockaddr_storage peer{};
NativeLength peer_length = sizeof(peer);
const int native_flags = flags == 2 ? MSG_PEEK : 0;
int result = ::recvfrom(socket.native->value, static_cast<char*>(buf), static_cast<int>(len),
native_flags, from ? reinterpret_cast<sockaddr*>(&peer) : nullptr, from ? &peer_length : nullptr);
#ifdef _WIN32
if (result < 0 && socket.type == NET_SOCK_DGRAM && WSAGetLastError() == WSAEMSGSIZE) result = static_cast<int>(len);
#endif
if (result < 0) return fail(receive_error(socket));
if (from && !native_to_guest_address(peer, from, fromlen)) return fail(NET_EAFNOSUPPORT);
return result;
}
int64_t APS5_VABI sceNetSend(int s, const void* buf, size_t len, int flags) {
if (flags != 0) return fail(NET_EOPNOTSUPP);
if (!buf && len) return fail(NET_EINVAL);
if (len > INT_MAX) return fail(NET_EMSGSIZE);
Sock socket;
{
std::lock_guard lk(g_mutex);
auto it = g_socks.find(s);
if (it == g_socks.end()) return fail(NET_EBADF);
socket = it->second;
}
const int result = ::send(socket.native->value, static_cast<const char*>(buf), static_cast<int>(len), NATIVE_SEND_FLAGS);
return result >= 0 ? result : fail(native_error());
}
int64_t APS5_VABI sceNetSendto(int s, const void* buf, size_t len, int flags, const void* to, uint32_t tolen) {
if (flags != 0) return fail(NET_EOPNOTSUPP);
if (!buf && len) return fail(NET_EINVAL);
if (len > INT_MAX) return fail(NET_EMSGSIZE);
Sock socket;
{
std::lock_guard lk(g_mutex);
auto it = g_socks.find(s);
if (it == g_socks.end()) return fail(NET_EBADF);
socket = it->second;
}
int result;
if (!to) {
if (tolen != 0) return fail(NET_EINVAL);
result = ::send(socket.native->value, static_cast<const char*>(buf), static_cast<int>(len), NATIVE_SEND_FLAGS);
} else {
sockaddr_storage destination{};
NativeLength destination_length = 0;
if (!guest_to_native_address(to, tolen, destination, destination_length)) return fail(NET_EINVAL);
if (destination.ss_family != (socket.family == NET_AF_INET ? AF_INET : AF_INET6)) return fail(NET_EAFNOSUPPORT);
result = ::sendto(socket.native->value, static_cast<const char*>(buf), static_cast<int>(len), NATIVE_SEND_FLAGS,
reinterpret_cast<const sockaddr*>(&destination), destination_length);
}
return result >= 0 ? result : fail(native_error());
}
int64_t APS5_VABI sceNetSendmsg(int s, const NetMsghdr* msg, int flags) {
const auto total = message_length(msg);
if (total < 0) return total;
if (msg->control && msg->control_length) throw std::runtime_error("sceNetSendmsg: control data is not supported");
std::vector<char> buffer;
try {
buffer.resize(static_cast<std::size_t>(total));
} catch (const std::bad_alloc&) {
return fail(55);
}
std::size_t offset = 0;
for (int i = 0; i < msg->iov_length; ++i) {
if (msg->iov[i].length) std::memcpy(buffer.data() + offset, msg->iov[i].base, msg->iov[i].length);
offset += msg->iov[i].length;
}
return sceNetSendto(s, buffer.data(), buffer.size(), flags, msg->name, msg->name ? msg->name_length : 0u);
}
int64_t APS5_VABI sceNetRecvmsg(int s, NetMsghdr* msg, int flags) {
const auto total = message_length(msg);
if (total < 0) return total;
if (flags != 0 && flags != NET_MSG_PEEK) return fail(NET_EOPNOTSUPP);
Sock socket;
{
std::lock_guard lk(g_mutex);
auto it = g_socks.find(s);
if (it == g_socks.end()) return fail(NET_EBADF);
socket = it->second;
}
const bool datagram = socket.type != NET_SOCK_STREAM;
std::vector<char> buffer;
try {
buffer.resize(static_cast<std::size_t>(total) + (datagram ? 1u : 0u));
} catch (const std::bad_alloc&) {
return fail(55);
}
sockaddr_storage peer{};
NativeLength peer_length = sizeof(peer);
std::int64_t received = ::recvfrom(socket.native->value, buffer.data(), static_cast<int>(buffer.size()),
flags == NET_MSG_PEEK ? MSG_PEEK : 0, reinterpret_cast<sockaddr*>(&peer), &peer_length);
if (received < 0) {
#ifdef _WIN32
if (!datagram || WSAGetLastError() != WSAEMSGSIZE) return fail(receive_error(socket));
received = static_cast<std::int64_t>(buffer.size());
#else
return fail(native_error());
#endif
}
msg->flags = 0;
if (received > total) {
received = total;
msg->flags = NET_MSG_TRUNC;
}
std::size_t offset = 0;
for (int i = 0; i < msg->iov_length && offset < static_cast<std::size_t>(received); ++i) {
const auto count = std::min<std::size_t>(msg->iov[i].length, static_cast<std::size_t>(received) - offset);
std::memcpy(msg->iov[i].base, buffer.data() + offset, count);
offset += count;
}
if (msg->name && !native_to_guest_address(peer, msg->name, &msg->name_length)) msg->name_length = 0;
msg->control_length = 0;
return received;
}
int APS5_VABI sceNetShutdown(int s, int how) {
if (how < 0 || how > 2) return fail(NET_EINVAL);
Sock socket;
{
std::lock_guard lk(g_mutex);
auto it = g_socks.find(s);
if (it == g_socks.end()) return fail(NET_EBADF);
socket = it->second;
}
return ::shutdown(socket.native->value, how) == 0 ? 0 : fail(native_error());
}
int APS5_VABI sceNetSetsockopt(int s, int level, int optname, const void* optval, uint32_t optlen) {
Sock socket;
{
std::lock_guard lk(g_mutex);
auto it = g_socks.find(s);
if (it == g_socks.end()) return fail(NET_EBADF);
socket = it->second;
}
if (level != NET_SOL_SOCKET) return fail(NET_EOPNOTSUPP);
if (!optval || optlen < sizeof(int)) return fail(NET_EINVAL);
int value = 0;
std::memcpy(&value, optval, sizeof(value));
if (optname == NET_SO_NBIO) {
#ifdef _WIN32
u_long enabled = value != 0;
if (ioctlsocket(socket.native->value, FIONBIO, &enabled) != 0) return fail(native_error());
#else
const int old_flags = fcntl(socket.native->value, F_GETFL, 0);
if (old_flags < 0 || fcntl(socket.native->value, F_SETFL,
value ? old_flags | O_NONBLOCK : old_flags & ~O_NONBLOCK) != 0) return fail(native_error());
#endif
} else if (optname == NET_SO_RCVTIMEO || optname == NET_SO_SNDTIMEO) {
if (value < 0) return fail(NET_EINVAL);
if (set_native_timeout(socket.native->value, optname, value) != 0) return fail(native_error());
} else if (optname == NET_SO_REUSEADDR || optname == NET_SO_BROADCAST || optname == NET_SO_SNDBUF || optname == NET_SO_RCVBUF) {
const int native_option = optname == NET_SO_REUSEADDR ? SO_REUSEADDR : optname == NET_SO_BROADCAST ? SO_BROADCAST : optname == NET_SO_SNDBUF ? SO_SNDBUF : SO_RCVBUF;
if (::setsockopt(socket.native->value, SOL_SOCKET, native_option, reinterpret_cast<const char*>(&value), sizeof(value)) != 0)
return fail(native_error());
} else {
return fail(NET_EOPNOTSUPP);
}
std::lock_guard lk(g_mutex);
auto it = g_socks.find(s);
if (it != g_socks.end()) {
if (optname == NET_SO_NBIO) it->second.nonblock = value != 0;
if (optname == NET_SO_RCVTIMEO) it->second.rcv_timeout_us = value;
if (optname == NET_SO_SNDTIMEO) it->second.snd_timeout_us = value;
}
return 0;
}
int APS5_VABI sceNetGetsockopt(int s, int level, int optname, void* optval, uint32_t* optlen) {
Sock socket;
{
std::lock_guard lk(g_mutex);
auto it = g_socks.find(s);
if (it == g_socks.end()) return fail(NET_EBADF);
socket = it->second;
}
if (optval == nullptr || optlen == nullptr || *optlen < sizeof(int)) {
return fail(NET_EINVAL);
}
if (level != NET_SOL_SOCKET) return fail(NET_EOPNOTSUPP);
int value = 0;
switch (optname) {
case NET_SO_NBIO: value = socket.nonblock ? 1 : 0; break;
case NET_SO_RCVTIMEO: value = socket.rcv_timeout_us; break;
case NET_SO_SNDTIMEO: value = socket.snd_timeout_us; break;
default: return fail(NET_EOPNOTSUPP);
}
std::memcpy(optval, &value, sizeof(value));
*optlen = sizeof(value);
return 0;
}
int APS5_VABI sceNetGetsockname(int s, void* addr, uint32_t* addrlen) {
Sock socket;
{
std::lock_guard lk(g_mutex);
auto it = g_socks.find(s);
if (it == g_socks.end()) return fail(NET_EBADF);
socket = it->second;
}
if (!addr || !addrlen) return fail(NET_EINVAL);
sockaddr_storage native{};
NativeLength native_length = sizeof(native);
if (::getsockname(socket.native->value, reinterpret_cast<sockaddr*>(&native), &native_length) != 0)
return fail(native_error());
return native_to_guest_address(native, addr, addrlen) ? 0 : fail(NET_EAFNOSUPPORT);
}
int APS5_VABI sceNetGetpeername(int s, void* addr, uint32_t* addrlen) {
Sock socket;
{
std::lock_guard lk(g_mutex);
auto it = g_socks.find(s);
if (it == g_socks.end()) return fail(NET_EBADF);
socket = it->second;
}
if (!addr || !addrlen) return fail(NET_EINVAL);
sockaddr_storage native{};
NativeLength native_length = sizeof(native);
if (::getpeername(socket.native->value, reinterpret_cast<sockaddr*>(&native), &native_length) != 0)
return fail(native_error());
return native_to_guest_address(native, addr, addrlen) ? 0 : fail(NET_EAFNOSUPPORT);
}
int APS5_VABI sceNetGetSockInfo(int s, void* info, int n, int flags) {
(void)info;
(void)n;
(void)flags;
std::lock_guard lk(g_mutex);
return g_socks.count(s) != 0 ? 0 : fail(NET_EBADF);
}
int APS5_VABI sceNetEpollCreate(const char* name, int flags) {
(void)name;
(void)flags;
std::lock_guard lk(g_mutex);
const int id = g_next_epoll++;
g_epolls.insert(id);
g_epoll_socks.emplace(id, std::map<int, NetEpollEvent>{});
return id;
}
int APS5_VABI sceNetGetMemoryPoolStats(int memid, NetMemoryPoolStats* stats) {
std::lock_guard lk(g_mutex);
const auto pool = g_pools.find(memid);
if (pool == g_pools.end()) {
return fail(NET_EBADF);
}
if (stats == nullptr) {
return fail(NET_EINVAL);
}
*stats = {pool->second, 0, 0};
return 0;
}
int APS5_VABI sceNetEpollDestroy(int eid) {
std::lock_guard lk(g_mutex);
if (g_epolls.erase(eid) == 0) {
return fail(NET_EBADF);
}
g_epoll_socks.erase(eid);
g_epoll_aborted.erase(eid);
g_cv.NotifyAll();
return 0;
}
int APS5_VABI sceNetEpollAbort(int eid, int flags) {
(void)flags;
std::lock_guard lk(g_mutex);
if (g_epolls.count(eid) == 0) {
return fail(NET_EBADF);
}
g_epoll_aborted.insert(eid);
g_cv.NotifyAll();
return 0;
}
int APS5_VABI sceNetEpollControl(int eid, int op, int id, const NetEpollEvent* event) {
std::lock_guard lk(g_mutex);
if (g_epolls.count(eid) == 0) {
return fail(NET_EBADF);
}
if (op != NET_EPOLL_CTL_ADD && op != NET_EPOLL_CTL_MOD && op != NET_EPOLL_CTL_DEL) return fail(NET_EINVAL);
if (op != NET_EPOLL_CTL_DEL && !event) return fail(NET_EINVAL);
if (op != NET_EPOLL_CTL_DEL && g_socks.count(id) == 0) return fail(NET_EBADF);
auto& registrations = g_epoll_socks[eid];
if (op == NET_EPOLL_CTL_ADD) {
if (!registrations.emplace(id, *event).second) return fail(NET_EADDRINUSE);
} else if (op == NET_EPOLL_CTL_DEL) {
if (registrations.erase(id) == 0) return fail(NET_ENOENT);
} else {
auto registration = registrations.find(id);
if (registration == registrations.end()) return fail(NET_ENOENT);
registration->second = *event;
}
g_cv.NotifyAll();
return 0;
}
int APS5_VABI sceNetEpollWait(int eid, NetEpollEvent* events, int maxevents, int timeout) {
if (!events || maxevents <= 0) return fail(NET_EINVAL);
const auto deadline = timeout > 0
? std::chrono::steady_clock::now() + std::chrono::microseconds(timeout)
: std::chrono::steady_clock::time_point::max();
for (;;) {
std::vector<NetEpollEvent> registered_events;
std::vector<std::shared_ptr<NativeSocketHandle>> native_sockets;
{
std::lock_guard lk(g_mutex);
if (g_epolls.count(eid) == 0) return fail(NET_EBADF);
if (g_epoll_aborted.erase(eid) != 0) return fail(NET_ECONNABORTED);
const auto registration = g_epoll_socks.find(eid);
if (registration != g_epoll_socks.end()) {
for (const auto& entry : registration->second) {
const auto socket = g_socks.find(entry.first);
if (socket == g_socks.end()) continue;
registered_events.push_back(entry.second);
native_sockets.push_back(socket->second.native);
}
}
}
if (registered_events.empty()) {
if (timeout == 0) return 0;
std::unique_lock lk(g_mutex);
const auto now = std::chrono::steady_clock::now();
if (timeout > 0 && now >= deadline) return 0;
const auto slice = std::chrono::milliseconds(100);
const auto wake = timeout > 0 ? std::min(deadline, now + slice) : now + slice;
g_cv.WaitUntil(lk, wake);
continue;
}
#ifdef _WIN32
std::vector<WSAPOLLFD> descriptors(registered_events.size());
for (std::size_t index = 0; index < descriptors.size(); ++index) {
descriptors[index].fd = native_sockets[index]->value;
if (registered_events[index].events & 1) descriptors[index].events |= POLLRDNORM;
if (registered_events[index].events & 4) descriptors[index].events |= POLLWRNORM;
}
#else
std::vector<pollfd> descriptors(registered_events.size());
for (std::size_t index = 0; index < descriptors.size(); ++index) {
descriptors[index].fd = native_sockets[index]->value;
if (registered_events[index].events & 1) descriptors[index].events |= POLLIN;
if (registered_events[index].events & 4) descriptors[index].events |= POLLOUT;
}
#endif
const auto now = std::chrono::steady_clock::now();
if (timeout > 0 && now >= deadline) return 0;
int wait_ms = 100;
if (timeout == 0) wait_ms = 0;
else if (timeout > 0) {
const auto remaining = std::chrono::duration_cast<std::chrono::microseconds>(deadline - now).count();
wait_ms = static_cast<int>(std::min<std::int64_t>(100, (remaining + 999) / 1000));
}
#ifdef _WIN32
const int ready_count = WSAPoll(descriptors.data(), static_cast<ULONG>(descriptors.size()), wait_ms);
#else
const int ready_count = ::poll(descriptors.data(), descriptors.size(), wait_ms);
#endif
if (ready_count < 0) return fail(native_error());
{
std::lock_guard lk(g_mutex);
if (g_epolls.count(eid) == 0) return fail(NET_EBADF);
if (g_epoll_aborted.erase(eid) != 0) return fail(NET_ECONNABORTED);
}
if (ready_count > 0) {
int count = 0;
for (std::size_t index = 0; index < descriptors.size() && count < maxevents; ++index) {
const auto native_events = descriptors[index].revents;
if (!native_events) continue;
std::uint32_t guest_events = 0;
#ifdef _WIN32
if (native_events & (POLLRDNORM | POLLPRI)) guest_events |= 1;
if (native_events & POLLWRNORM) guest_events |= 4;
#else
if (native_events & (POLLIN | POLLPRI)) guest_events |= 1;
if (native_events & POLLOUT) guest_events |= 4;
#endif
if (native_events & POLLERR) guest_events |= 8;
if (native_events & POLLHUP) guest_events |= 16;
events[count] = registered_events[index];
events[count].events = guest_events;
++count;
}
if (count > 0) return count;
}
if (timeout == 0) return 0;
}
}
// Byte order and text conversion.
uint32_t APS5_VABI sceNetHtonl_nid_postfix(uint32_t host32) { return swap32(host32); }
uint16_t APS5_VABI sceNetHtons_nid_postfix(uint16_t host16) { return swap16(host16); }
uint64_t APS5_VABI sceNetHtonll(std::uint64_t host64) { return swap64(host64); }
uint64_t APS5_VABI sceNetNtohll(std::uint64_t net64) { return swap64(net64); }
uint32_t APS5_VABI sceNetNtohl_nid_postfix(uint32_t net32) { return swap32(net32); }
uint16_t APS5_VABI sceNetNtohs_nid_postfix(uint16_t net16) { return swap16(net16); }
int APS5_VABI sceNetInetPton(int af, const char* src, void* dst) {
if (src == nullptr || dst == nullptr) {
return fail(NET_EINVAL);
}
if (af != NET_AF_INET && af != NET_AF_INET6) {
return fail(NET_EAFNOSUPPORT);
}
#ifdef _WIN32
return InetPtonA(af == NET_AF_INET ? AF_INET : AF_INET6, src, dst);
#else
return ::inet_pton(af == NET_AF_INET ? AF_INET : AF_INET6, src, dst);
#endif
}
const char* APS5_VABI sceNetInetNtop(int af, const void* src, char* dst, uint32_t size) {
if (src == nullptr || dst == nullptr) {
set_errno(NET_EINVAL);
return nullptr;
}
if (af != NET_AF_INET && af != NET_AF_INET6) {
set_errno(NET_EAFNOSUPPORT);
return nullptr;
}
char text[INET6_ADDRSTRLEN];
#ifdef _WIN32
const auto* result = InetNtopA(af == NET_AF_INET ? AF_INET : AF_INET6, const_cast<void*>(src), text, sizeof(text));
#else
const auto* result = ::inet_ntop(af == NET_AF_INET ? AF_INET : AF_INET6, src, text, sizeof(text));
#endif
if (!result) {
set_errno(native_error());
return nullptr;
}
const auto length = std::strlen(text) + 1;
if (length > size) {
set_errno(NET_ENOSPC);
return nullptr;
}
std::memcpy(dst, text, length);
return dst;
}
int APS5_VABI sceNetEtherNtostr(const NetEtherAddr* n, char* str, size_t len) {
if (n == nullptr || str == nullptr || len < 18) {
return fail(NET_EINVAL);
}
std::snprintf(str, len, "%02x:%02x:%02x:%02x:%02x:%02x", n->data[0], n->data[1], n->data[2], n->data[3], n->data[4], n->data[5]);
return 0;
}
int APS5_VABI sceNetGetMacAddress(NetEtherAddr* addr, int flags) {
(void)flags;
if (addr == nullptr) {
return fail(NET_EINVAL);
}
// Keep guest identity stable without exposing the host adapter address.
const std::uint8_t mac[6] = {0x02, 0x50, 0x53, 0x35, 0x00, 0x01};
std::memcpy(addr->data, mac, 6);
return 0;
}
// Resolver results use the guest IPv4 address format while delegating lookup to host DNS.
int APS5_VABI sceNetResolverCreate(const char* name, int memid, int flags) {
(void)name;
(void)memid;
(void)flags;
std::lock_guard lk(g_mutex);
const int id = g_next_resolver++;
g_resolvers[id] = {};
return id;
}
int APS5_VABI sceNetResolverDestroy(int rid) {
std::lock_guard lk(g_mutex);
return g_resolvers.erase(rid) != 0 ? 0 : fail(NET_EBADF);
}
int lookup_ipv4(int rid, const char* hostname, const char* func, std::vector<std::uint32_t>& addresses) {
if (!initialize_sockets()) return fail(5);
std::uint64_t generation = 0;
if (const int error = begin_lookup(rid, &Resolver::abort_ntoa, generation)) return error;
addrinfo hints{};
hints.ai_family = AF_INET;
addrinfo* results = nullptr;
const int result = ::getaddrinfo(hostname, nullptr, &hints, &results);
if (result != 0) {
set_errno(result == EAI_AGAIN ? NET_ETIMEDOUT : NET_ENOENT);
log_soft(func, "host DNS lookup failed");
return end_lookup(rid, generation, NET_ERROR_RESOLVER_ENODNS);
}
for (const addrinfo* entry = results; entry != nullptr; entry = entry->ai_next) {
const auto address = reinterpret_cast<const sockaddr_in*>(entry->ai_addr)->sin_addr.s_addr;
if (std::find(addresses.begin(), addresses.end(), address) == addresses.end()) addresses.push_back(address);
}
::freeaddrinfo(results);
return end_lookup(rid, generation, 0);
}
int APS5_VABI sceNetResolverStartNtoa(int rid, const char* hostname, void* addr, int timeout, int retry, int flags) {
(void)timeout;
(void)retry;
(void)flags;
if (!hostname || !addr) return fail(NET_EINVAL);
std::vector<std::uint32_t> addresses;
if (const int error = lookup_ipv4(rid, hostname, __func__, addresses)) return error;
std::memcpy(addr, addresses.data(), sizeof(addresses[0]));
return 0;
}
struct NetResolverRecord {
std::uint32_t address;
std::uint8_t address6[12];
std::int32_t family;
std::int32_t reserved[3];
};
struct NetResolverInfo {
NetResolverRecord records[10];
std::int32_t count;
std::int32_t count4;
std::int32_t reserved[14];
};
static_assert(sizeof(NetResolverRecord) == 32 && offsetof(NetResolverRecord, family) == 16);
static_assert(sizeof(NetResolverInfo) == 384 && offsetof(NetResolverInfo, count) == 320 && offsetof(NetResolverInfo, count4) == 324);
int lookup_records(int rid, const char* hostname, NetResolverInfo* info, int flags, const char* func) {
if (flags != 0) throw std::runtime_error(std::string(func) + ": flags " + std::to_string(flags) + " are not supported");
if (!hostname || !info) return fail(NET_EINVAL);
std::vector<std::uint32_t> addresses;
if (const int error = lookup_ipv4(rid, hostname, func, addresses)) return error;
*info = {};
info->count = static_cast<std::int32_t>(std::min<std::size_t>(addresses.size(), std::size(info->records)));
info->count4 = info->count;
for (std::int32_t index = 0; index < info->count; ++index) {
info->records[index].address = addresses[index];
info->records[index].family = NET_AF_INET;
}
return 0;
}
int APS5_VABI sceNetResolverStartNtoaMultipleRecords(int rid, const char* hostname, NetResolverInfo* info, int timeout,
int retry, int flags) {
(void)timeout;
(void)retry;
return lookup_records(rid, hostname, info, flags, __func__);
}
int APS5_VABI sceNetResolverStartNtoaMultipleRecordsEx(int rid, const char* hostname, NetResolverInfo* info, int timeout,
int retry, int flags) {
(void)timeout;
(void)retry;
return lookup_records(rid, hostname, info, flags, __func__);
}
int APS5_VABI sceNetResolverStartAton(int rid, const void* addr, char* hostname, int len, int timeout, int retry, int flags) {
(void)timeout;
(void)retry;
(void)flags;
if (!addr || !hostname || len <= 0) return fail(NET_EINVAL);
if (!initialize_sockets()) return fail(5);
std::uint64_t generation = 0;
if (const int error = begin_lookup(rid, &Resolver::abort_aton, generation)) return error;
sockaddr_in address{};
address.sin_family = AF_INET;
std::memcpy(&address.sin_addr, addr, sizeof(address.sin_addr));
std::vector<char> name(static_cast<std::size_t>(len));
const int result = ::getnameinfo(reinterpret_cast<const sockaddr*>(&address), sizeof(address), name.data(),
static_cast<NativeLength>(len), nullptr, 0, NI_NAMEREQD);
if (result != 0) {
set_errno(result == EAI_AGAIN ? NET_ETIMEDOUT : NET_ENOENT);
log_soft(__func__, "host reverse DNS lookup failed");
return end_lookup(rid, generation, NET_ERROR_RESOLVER_ENODNS);
}
if (const int error = end_lookup(rid, generation, 0)) return error;
std::memcpy(hostname, name.data(), std::strlen(name.data()) + 1);
return 0;
}
int APS5_VABI sceNetResolverGetError(int rid, int* status) {
if (!status) return fail(NET_EINVAL);
std::lock_guard lk(g_mutex);
const auto resolver = g_resolvers.find(rid);
if (resolver == g_resolvers.end()) return fail(NET_EBADF);
*status = resolver->second.error;
return 0;
}
int APS5_VABI sceNetResolverAbort(int rid, int flags) {
constexpr int preservation = NET_RESOLVER_ABORT_FLAG_NTOA_PRESERVATION | NET_RESOLVER_ABORT_FLAG_ATON_PRESERVATION;
std::lock_guard lk(g_mutex);
const auto resolver = g_resolvers.find(rid);
if (resolver == g_resolvers.end()) return fail(NET_EBADF);
if ((flags & ~preservation) != 0) throw std::runtime_error("sceNetResolverAbort: flags " + std::to_string(flags) + " are not supported");
if (resolver->second.running != 0) {
++resolver->second.aborts;
resolver->second.error = NET_ERROR_BASE | NET_EINTR;
return 0;
}
if ((flags & NET_RESOLVER_ABORT_FLAG_NTOA_PRESERVATION) != 0) resolver->second.abort_ntoa = true;
if ((flags & NET_RESOLVER_ABORT_FLAG_ATON_PRESERVATION) != 0) resolver->second.abort_aton = true;
return 0;
}
int APS5_VABI sceNetShowIfconfig() {
NotImplemented_nid_no_patch(__func__);
return 0;
}
extern const std::uint8_t in6addr_any_nid_postfix[16] = {};
extern const std::uint8_t in6addr_loopback_nid_postfix[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1};
}
Reference in new issue View Git Blame Copy Permalink