mirror/rpcs3
1
0
Fork 0
mirror of https://github.com/RPCS3/rpcs3.git synced 2025-02-11 15:40:51 +00:00
Code Issues Packages Projects Releases Wiki Activity

sys_net fixed

Browse Source
This commit is contained in:
Nekotekina 2015-02-21 16:05:35 +03:00
parent 6b4b86434d
commit a182743561
4 changed files with 283 additions and 283 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
rpcs3/Emu/SysCalls/Modules.h
View File

@ -123,7 +123,7 @@ u32 add_ppu_func_sub(const char group[8], const u64 ops[], const char* name, Mod
#define REG_FUNC(module, name) add_ppu_func(ModuleFunc(get_function_id(#name), &module, bind_func(name)))
#define REG_FUNC2(module, nid, name) add_ppu_func(ModuleFunc(nid, &module, bind_func(name)))
#define REG_UNNAMED(module, nid) add_ppu_func(ModuleFunc(0x##nid, &module, bind_func(_nid_##nid)))
#define REG_SUB(module, group, name, ...) \
static const u64 name ## _table[] = {__VA_ARGS__ , 0}; \

2
rpcs3/Emu/SysCalls/Modules/sysPrxForUser.cpp
View File

@ -674,5 +674,5 @@ Module sysPrxForUser("sysPrxForUser", []()
REG_FUNC(sysPrxForUser, _sys_printf);
REG_FUNC2(sysPrxForUser, 0xE75C40F2, _nid_E75C40F2);
REG_UNNAMED(sysPrxForUser, E75C40F2);
});

558
rpcs3/Emu/SysCalls/Modules/sys_net.cpp
View File

@ -85,320 +85,324 @@ s32 getLastError()
return errno;
#endif
}
#ifdef _WIN32
using pck_len_t = s32;
#else
using pck_len_t = u32;
#endif
// Functions
int sys_net_accept(s32 s, vm::ptr<sys_net_sockaddr> addr, vm::ptr<pck_len_t> paddrlen)
namespace sys_net_func
{
sys_net.Warning("accept(s=%d, family_addr=0x%x, paddrlen=0x%x)", s, addr.addr(), paddrlen.addr());
if (!addr) {
int ret = accept(s, nullptr, nullptr);
// Functions
s32 accept(s32 s, vm::ptr<sys_net_sockaddr> addr, vm::ptr<pck_len_t> paddrlen)
{
sys_net.Warning("accept(s=%d, family_addr=0x%x, paddrlen=0x%x)", s, addr.addr(), paddrlen.addr());
if (!addr) {
int ret = ::accept(s, nullptr, nullptr);
*g_lastError = getLastError();
return ret;
}
else {
sockaddr _addr;
memcpy(&_addr, addr.get_ptr(), sizeof(sockaddr));
_addr.sa_family = addr->sa_family;
pck_len_t _paddrlen;
int ret = ::accept(s, &_addr, &_paddrlen);
*paddrlen = _paddrlen;
*g_lastError = getLastError();
return ret;
}
}
s32 bind(s32 s, vm::ptr<sys_net_sockaddr_in> addr, u32 addrlen)
{
sys_net.Warning("bind(s=%d, family_addr=0x%x, addrlen=%d)", s, addr.addr(), addrlen);
sockaddr_in saddr;
memcpy(&saddr, addr.get_ptr(), sizeof(sockaddr_in));
saddr.sin_family = addr->sin_family;
const char *ipaddr = inet_ntoa(saddr.sin_addr);
sys_net.Warning("binding on %s to port %d", ipaddr, ntohs(saddr.sin_port));
int ret = ::bind(s, (const sockaddr *)&saddr, addrlen);
*g_lastError = getLastError();
return ret;
}
else {
s32 connect(s32 s, vm::ptr<sys_net_sockaddr_in> addr, u32 addrlen)
{
sys_net.Warning("connect(s=%d, family_addr=0x%x, addrlen=%d)", s, addr.addr(), addrlen);
sockaddr_in saddr;
memcpy(&saddr, addr.get_ptr(), sizeof(sockaddr_in));
saddr.sin_family = addr->sin_family;
const char *ipaddr = inet_ntoa(saddr.sin_addr);
sys_net.Warning("connecting on %s to port %d", ipaddr, ntohs(saddr.sin_port));
int ret = ::connect(s, (const sockaddr *)&saddr, addrlen);
*g_lastError = getLastError();
return ret;
}
s32 gethostbyaddr()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
s32 gethostbyname()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
s32 getpeername()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
s32 getsockname()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
s32 getsockopt()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
s32 inet_addr(vm::ptr<const char> cp)
{
sys_net.Warning("inet_addr(cp_addr=0x%x['%s'])", cp.addr(), cp.get_ptr());
return htonl(::inet_addr(cp.get_ptr())); // return a big-endian IP address (WTF? function should return LITTLE-ENDIAN value)
}
s32 inet_aton()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
s32 inet_lnaof()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
s32 inet_makeaddr()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
s32 inet_netof()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
s32 inet_network()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
s32 inet_ntoa()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
s32 inet_ntop()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
s32 inet_pton(s32 af, vm::ptr<const char> src, vm::ptr<char> dst)
{
sys_net.Warning("inet_pton(af=%d, src_addr=0x%x, dst_addr=0x%x)", af, src.addr(), dst.addr());
return ::inet_pton(af, src.get_ptr(), dst.get_ptr());
}
s32 listen(s32 s, s32 backlog)
{
sys_net.Warning("listen(s=%d, backlog=%d)", s, backlog);
int ret = ::listen(s, backlog);
*g_lastError = getLastError();
return ret;
}
s32 recv(s32 s, vm::ptr<char> buf, u32 len, s32 flags)
{
sys_net.Warning("recv(s=%d, buf_addr=0x%x, len=%d, flags=0x%x)", s, buf.addr(), len, flags);
int ret = ::recv(s, buf.get_ptr(), len, flags);
*g_lastError = getLastError();
return ret;
}
s32 recvfrom(s32 s, vm::ptr<char> buf, u32 len, s32 flags, vm::ptr<sys_net_sockaddr> addr, vm::ptr<pck_len_t> paddrlen)
{
sys_net.Warning("recvfrom(s=%d, buf_addr=0x%x, len=%d, flags=0x%x, addr_addr=0x%x, paddrlen=0x%x)",
s, buf.addr(), len, flags, addr.addr(), paddrlen.addr());
sockaddr _addr;
memcpy(&_addr, addr.get_ptr(), sizeof(sockaddr));
_addr.sa_family = addr->sa_family;
pck_len_t _paddrlen;
int ret = accept(s, &_addr, &_paddrlen);
int ret = ::recvfrom(s, buf.get_ptr(), len, flags, &_addr, &_paddrlen);
*paddrlen = _paddrlen;
*g_lastError = getLastError();
return ret;
}
}
int sys_net_bind(s32 s, vm::ptr<sys_net_sockaddr_in> addr, u32 addrlen)
{
sys_net.Warning("bind(s=%d, family_addr=0x%x, addrlen=%d)", s, addr.addr(), addrlen);
sockaddr_in saddr;
memcpy(&saddr, addr.get_ptr(), sizeof(sockaddr_in));
saddr.sin_family = addr->sin_family;
const char *ipaddr = inet_ntoa(saddr.sin_addr);
sys_net.Warning("binding on %s to port %d", ipaddr, ntohs(saddr.sin_port));
int ret = bind(s, (const sockaddr *)&saddr, addrlen);
*g_lastError = getLastError();
return ret;
}
s32 recvmsg()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
int sys_net_connect(s32 s, vm::ptr<sys_net_sockaddr_in> addr, u32 addrlen)
{
sys_net.Warning("connect(s=%d, family_addr=0x%x, addrlen=%d)", s, addr.addr(), addrlen);
sockaddr_in saddr;
memcpy(&saddr, addr.get_ptr(), sizeof(sockaddr_in));
saddr.sin_family = addr->sin_family;
const char *ipaddr = inet_ntoa(saddr.sin_addr);
sys_net.Warning("connecting on %s to port %d", ipaddr, ntohs(saddr.sin_port));
int ret = connect(s, (const sockaddr *) &saddr, addrlen);
*g_lastError = getLastError();
return ret;
}
s32 send(s32 s, vm::ptr<const char> buf, u32 len, s32 flags)
{
sys_net.Warning("send(s=%d, buf_addr=0x%x, len=%d, flags=0x%x)", s, buf.addr(), len, flags);
int gethostbyaddr()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
int ret = ::send(s, buf.get_ptr(), len, flags);
*g_lastError = getLastError();
return ret;
}
int gethostbyname()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
s32 sendmsg()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
int getpeername()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
s32 sendto(s32 s, vm::ptr<const char> buf, u32 len, s32 flags, vm::ptr<sys_net_sockaddr> addr, u32 addrlen)
{
sys_net.Warning("sendto(s=%d, buf_addr=0x%x, len=%d, flags=0x%x, addr=0x%x, addrlen=%d)",
s, buf.addr(), len, flags, addr.addr(), addrlen);
int getsockname()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
sockaddr _addr;
memcpy(&_addr, addr.get_ptr(), sizeof(sockaddr));
_addr.sa_family = addr->sa_family;
int ret = ::sendto(s, buf.get_ptr(), len, flags, &_addr, addrlen);
*g_lastError = getLastError();
return ret;
}
int getsockopt()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
s32 setsockopt(s32 s, s32 level, s32 optname, vm::ptr<const char> optval, u32 optlen)
{
sys_net.Warning("socket(s=%d, level=%d, optname=%d, optval_addr=0x%x, optlen=%d)", s, level, optname, optval.addr(), optlen);
int sys_net_inet_addr(vm::ptr<const char> cp)
{
sys_net.Warning("inet_addr(cp_addr=0x%x['%s'])", cp.addr(), cp.get_ptr());
return htonl(inet_addr(cp.get_ptr())); // return a big-endian IP address
}
int ret = ::setsockopt(s, level, optname, optval.get_ptr(), optlen);
*g_lastError = getLastError();
return ret;
}
int inet_aton()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
s32 shutdown(s32 s, s32 how)
{
sys_net.Warning("shutdown(s=%d, how=%d)", s, how);
int ret = ::shutdown(s, how);
*g_lastError = getLastError();
return ret;
}
int inet_lnaof()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
s32 socket(s32 family, s32 type, s32 protocol)
{
sys_net.Warning("socket(family=%d, type=%d, protocol=%d)", family, type, protocol);
int ret = ::socket(family, type, protocol);
*g_lastError = getLastError();
return ret;
}
int inet_makeaddr()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
int inet_netof()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
int inet_network()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
int inet_ntoa()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
int inet_ntop()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
int sys_net_inet_pton(s32 af, vm::ptr<const char> src, vm::ptr<char> dst)
{
sys_net.Warning("inet_pton(af=%d, src_addr=0x%x, dst_addr=0x%x)", af, src.addr(), dst.addr());
return inet_pton(af, src.get_ptr(), dst.get_ptr());
}
int sys_net_listen(s32 s, s32 backlog)
{
sys_net.Warning("listen(s=%d, backlog=%d)", s, backlog);
int ret = listen(s, backlog);
*g_lastError = getLastError();
return ret;
}
int sys_net_recv(s32 s, vm::ptr<char> buf, u32 len, s32 flags)
{
sys_net.Warning("recv(s=%d, buf_addr=0x%x, len=%d, flags=0x%x)", s, buf.addr(), len, flags);
int ret = recv(s, buf.get_ptr(), len, flags);
*g_lastError = getLastError();
return ret;
}
int sys_net_recvfrom(s32 s, vm::ptr<char> buf, u32 len, s32 flags, vm::ptr<sys_net_sockaddr> addr, vm::ptr<pck_len_t> paddrlen)
{
sys_net.Warning("recvfrom(s=%d, buf_addr=0x%x, len=%d, flags=0x%x, addr_addr=0x%x, paddrlen=0x%x)",
s, buf.addr(), len, flags, addr.addr(), paddrlen.addr());
sockaddr _addr;
memcpy(&_addr, addr.get_ptr(), sizeof(sockaddr));
_addr.sa_family = addr->sa_family;
pck_len_t _paddrlen;
int ret = recvfrom(s, buf.get_ptr(), len, flags, &_addr, &_paddrlen);
*paddrlen = _paddrlen;
*g_lastError = getLastError();
return ret;
}
int recvmsg()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
int sys_net_send(s32 s, vm::ptr<const char> buf, u32 len, s32 flags)
{
sys_net.Warning("send(s=%d, buf_addr=0x%x, len=%d, flags=0x%x)", s, buf.addr(), len, flags);
int ret = send(s, buf.get_ptr(), len, flags);
*g_lastError = getLastError();
return ret;
}
int sendmsg()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
int sys_net_sendto(s32 s, vm::ptr<const char> buf, u32 len, s32 flags, vm::ptr<sys_net_sockaddr> addr, u32 addrlen)
{
sys_net.Warning("sendto(s=%d, buf_addr=0x%x, len=%d, flags=0x%x, addr=0x%x, addrlen=%d)",
s, buf.addr(), len, flags, addr.addr(), addrlen);
sockaddr _addr;
memcpy(&_addr, addr.get_ptr(), sizeof(sockaddr));
_addr.sa_family = addr->sa_family;
int ret = sendto(s, buf.get_ptr(), len, flags, &_addr, addrlen);
*g_lastError = getLastError();
return ret;
}
int sys_net_setsockopt(s32 s, s32 level, s32 optname, vm::ptr<const char> optval, u32 optlen)
{
sys_net.Warning("socket(s=%d, level=%d, optname=%d, optval_addr=0x%x, optlen=%d)", s, level, optname, optval.addr(), optlen);
int ret = setsockopt(s, level, optname, optval.get_ptr(), optlen);
*g_lastError = getLastError();
return ret;
}
int sys_net_shutdown(s32 s, s32 how)
{
sys_net.Warning("shutdown(s=%d, how=%d)", s, how);
int ret = shutdown(s, how);
*g_lastError = getLastError();
return ret;
}
int sys_net_socket(s32 family, s32 type, s32 protocol)
{
sys_net.Warning("socket(family=%d, type=%d, protocol=%d)", family, type, protocol);
int ret = socket(family, type, protocol);
*g_lastError = getLastError();
return ret;
}
int sys_net_socketclose(s32 s)
{
sys_net.Warning("socket(s=%d)", s);
s32 socketclose(s32 s)
{
sys_net.Warning("socket(s=%d)", s);
#ifdef _WIN32
int ret = closesocket(s);
int ret = ::closesocket(s);
#else
int ret = close(s);
int ret = ::close(s);
#endif
*g_lastError = getLastError();
return ret;
*g_lastError = getLastError();
return ret;
}
s32 socketpoll()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
s32 socketselect()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
}
int socketpoll()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
int socketselect()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
int sys_net_initialize_network_ex(vm::ptr<sys_net_initialize_parameter> param)
s32 sys_net_initialize_network_ex(vm::ptr<sys_net_initialize_parameter> param)
{
sys_net.Warning("sys_net_initialize_network_ex(param_addr=0x%x)", param.addr());
g_lastError = vm::ptr<s32>::make((u32)Memory.Alloc(4, 1));
#ifdef _WIN32
WSADATA wsaData;
WORD wVersionRequested = MAKEWORD(1,1);
WORD wVersionRequested = MAKEWORD(1, 1);
WSAStartup(wVersionRequested, &wsaData);
#endif
return CELL_OK;
}
int sys_net_get_udpp2p_test_param()
s32 sys_net_get_udpp2p_test_param()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
int sys_net_set_udpp2p_test_param()
s32 sys_net_set_udpp2p_test_param()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
int sys_net_get_lib_name_server()
s32 sys_net_get_lib_name_server()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
int sys_net_if_ctl()
s32 sys_net_if_ctl()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
int sys_net_get_netemu_test_param()
s32 sys_net_get_netemu_test_param()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
int sys_net_get_sockinfo()
s32 sys_net_get_sockinfo()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
int sys_net_close_dump()
s32 sys_net_close_dump()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
int sys_net_set_test_param()
s32 sys_net_set_test_param()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
int sys_net_show_nameserver()
s32 sys_net_show_nameserver()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
@ -410,67 +414,67 @@ u32 _sys_net_errno_loc()
return g_lastError.addr();
}
int sys_net_set_resolver_configurations()
s32 sys_net_set_resolver_configurations()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
int sys_net_show_route()
s32 sys_net_show_route()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
int sys_net_read_dump()
s32 sys_net_read_dump()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
int sys_net_abort_resolver()
s32 sys_net_abort_resolver()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
int sys_net_abort_socket()
s32 sys_net_abort_socket()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
int sys_net_set_lib_name_server()
s32 sys_net_set_lib_name_server()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
int sys_net_get_test_param()
s32 sys_net_get_test_param()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
int sys_net_get_sockinfo_ex()
s32 sys_net_get_sockinfo_ex()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
int sys_net_open_dump()
s32 sys_net_open_dump()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
int sys_net_show_ifconfig()
s32 sys_net_show_ifconfig()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
int sys_net_finalize_network()
s32 sys_net_finalize_network()
{
sys_net.Warning("sys_net_initialize_network_ex()");
Memory.Free(g_lastError.addr());
@ -481,59 +485,59 @@ int sys_net_finalize_network()
return CELL_OK;
}
int _sys_net_h_errno_loc()
s32 _sys_net_h_errno_loc()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
int sys_net_set_netemu_test_param()
s32 sys_net_set_netemu_test_param()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
int sys_net_free_thread_context()
s32 sys_net_free_thread_context()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
// define additional macro for specific namespace
#define REG_FUNC_(name) add_ppu_func(ModuleFunc(get_function_id(#name), &sys_net, bind_func(sys_net_func::name)))
Module sys_net("sys_net", []()
{
// The names of the following functions are modified to avoid overloading problems
REG_FUNC(sys_net, sys_net_accept);
REG_FUNC(sys_net, sys_net_bind);
REG_FUNC(sys_net, sys_net_connect);
//REG_FUNC(sys_net, sys_net_gethostbyaddr);
//REG_FUNC(sys_net, sys_net_gethostbyname);
//REG_FUNC(sys_net, sys_net_getpeername);
//REG_FUNC(sys_net, sys_net_getsockname);
//REG_FUNC(sys_net, sys_net_getsockopt);
REG_FUNC(sys_net, sys_net_inet_addr);
//REG_FUNC(sys_net, sys_net_inet_aton);
//REG_FUNC(sys_net, sys_net_inet_lnaof);
//REG_FUNC(sys_net, sys_net_inet_makeaddr);
//REG_FUNC(sys_net, sys_net_inet_netof);
//REG_FUNC(sys_net, sys_net_inet_network);
//REG_FUNC(sys_net, sys_net_inet_ntoa);
//REG_FUNC(sys_net, sys_net_inet_ntop);
REG_FUNC(sys_net, sys_net_inet_pton);
REG_FUNC(sys_net, sys_net_listen);
//sys_net.AddFunc(, sys_net_ntohl);
//sys_net.AddFunc(, sys_net_ntohs);
REG_FUNC(sys_net, sys_net_recv);
REG_FUNC(sys_net, sys_net_recvfrom);
//REG_FUNC(sys_net, sys_net_recvmsg);
REG_FUNC(sys_net, sys_net_send);
//REG_FUNC(sys_net, sys_net_sendmsg);
REG_FUNC(sys_net, sys_net_sendto);
REG_FUNC(sys_net, sys_net_setsockopt);
REG_FUNC(sys_net, sys_net_shutdown);
REG_FUNC(sys_net, sys_net_socket);
REG_FUNC(sys_net, sys_net_socketclose);
//REG_FUNC(sys_net, sys_net_socketpoll);
//REG_FUNC(sys_net, sys_net_socketselect);
REG_FUNC_(accept);
REG_FUNC_(bind);
REG_FUNC_(connect);
REG_FUNC_(gethostbyaddr);
REG_FUNC_(gethostbyname);
REG_FUNC_(getpeername);
REG_FUNC_(getsockname);
REG_FUNC_(getsockopt);
REG_FUNC_(inet_addr);
REG_FUNC_(inet_aton);
REG_FUNC_(inet_lnaof);
REG_FUNC_(inet_makeaddr);
REG_FUNC_(inet_netof);
REG_FUNC_(inet_network);
REG_FUNC_(inet_ntoa);
REG_FUNC_(inet_ntop);
REG_FUNC_(inet_pton);
REG_FUNC_(listen);
REG_FUNC_(recv);
REG_FUNC_(recvfrom);
REG_FUNC_(recvmsg);
REG_FUNC_(send);
REG_FUNC_(sendmsg);
REG_FUNC_(sendto);
REG_FUNC_(setsockopt);
REG_FUNC_(shutdown);
REG_FUNC_(socket);
REG_FUNC_(socketclose);
REG_FUNC_(socketpoll);
REG_FUNC_(socketselect);
REG_FUNC(sys_net, sys_net_initialize_network_ex);
REG_FUNC(sys_net, sys_net_get_udpp2p_test_param);

4
rpcs3/Emu/SysCalls/Static.h
View File

@ -1,9 +1,5 @@
#pragma once
struct SFunc;
class PPUThread;
class StaticFuncManager
{
public: