mirrors/rpcs3
0
0
Fork 0
mirror of https://github.com/RPCS3/rpcs3.git synced 2025-08-12 02:59:51 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

sys_net fixed

Browse source
This commit is contained in:
Nekotekina 2015-02-21 16:05:35 +03:00
commit a182743561
4 changed files with 283 additions and 283 deletions
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_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, ...) \ #define REG_SUB(module, group, name, ...) \
static const u64 name ## _table[] = {__VA_ARGS__ , 0}; \ 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_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; return errno;
#endif #endif
} }
#ifdef _WIN32 #ifdef _WIN32
using pck_len_t = s32; using pck_len_t = s32;
#else #else
using pck_len_t = u32; using pck_len_t = u32;
#endif #endif
// Functions namespace sys_net_func
int sys_net_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()); // Functions
if (!addr) { s32 accept(s32 s, vm::ptr<sys_net_sockaddr> addr, vm::ptr<pck_len_t> paddrlen)
int ret = accept(s, nullptr, nullptr); {
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(); *g_lastError = getLastError();
return ret; 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; sockaddr _addr;
memcpy(&_addr, addr.get_ptr(), sizeof(sockaddr)); memcpy(&_addr, addr.get_ptr(), sizeof(sockaddr));
_addr.sa_family = addr->sa_family; _addr.sa_family = addr->sa_family;
pck_len_t _paddrlen; pck_len_t _paddrlen;
int ret = accept(s, &_addr, &_paddrlen); int ret = ::recvfrom(s, buf.get_ptr(), len, flags, &_addr, &_paddrlen);
*paddrlen = _paddrlen; *paddrlen = _paddrlen;
*g_lastError = getLastError(); *g_lastError = getLastError();
return ret; return ret;
} }
}
int sys_net_bind(s32 s, vm::ptr<sys_net_sockaddr_in> addr, u32 addrlen) s32 recvmsg()
{ {
sys_net.Warning("bind(s=%d, family_addr=0x%x, addrlen=%d)", s, addr.addr(), addrlen); UNIMPLEMENTED_FUNC(sys_net);
sockaddr_in saddr; return CELL_OK;
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;
}
int sys_net_connect(s32 s, vm::ptr<sys_net_sockaddr_in> addr, u32 addrlen) s32 send(s32 s, vm::ptr<const char> buf, u32 len, s32 flags)
{ {
sys_net.Warning("connect(s=%d, family_addr=0x%x, addrlen=%d)", s, addr.addr(), addrlen); sys_net.Warning("send(s=%d, buf_addr=0x%x, len=%d, flags=0x%x)", s, buf.addr(), len, flags);
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;
}
int gethostbyaddr() int ret = ::send(s, buf.get_ptr(), len, flags);
{ *g_lastError = getLastError();
UNIMPLEMENTED_FUNC(sys_net); return ret;
return CELL_OK; }
}
int gethostbyname() s32 sendmsg()
{ {
UNIMPLEMENTED_FUNC(sys_net); UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK; return CELL_OK;
} }
int getpeername() s32 sendto(s32 s, vm::ptr<const char> buf, u32 len, s32 flags, vm::ptr<sys_net_sockaddr> addr, u32 addrlen)
{ {
UNIMPLEMENTED_FUNC(sys_net); sys_net.Warning("sendto(s=%d, buf_addr=0x%x, len=%d, flags=0x%x, addr=0x%x, addrlen=%d)",
return CELL_OK; s, buf.addr(), len, flags, addr.addr(), addrlen);
}
int getsockname() sockaddr _addr;
{ memcpy(&_addr, addr.get_ptr(), sizeof(sockaddr));
UNIMPLEMENTED_FUNC(sys_net); _addr.sa_family = addr->sa_family;
return CELL_OK; int ret = ::sendto(s, buf.get_ptr(), len, flags, &_addr, addrlen);
} *g_lastError = getLastError();
return ret;
}
int getsockopt() s32 setsockopt(s32 s, s32 level, s32 optname, vm::ptr<const char> optval, u32 optlen)
{ {
UNIMPLEMENTED_FUNC(sys_net); sys_net.Warning("socket(s=%d, level=%d, optname=%d, optval_addr=0x%x, optlen=%d)", s, level, optname, optval.addr(), optlen);
return CELL_OK;
}
int sys_net_inet_addr(vm::ptr<const char> cp) int ret = ::setsockopt(s, level, optname, optval.get_ptr(), optlen);
{ *g_lastError = getLastError();
sys_net.Warning("inet_addr(cp_addr=0x%x['%s'])", cp.addr(), cp.get_ptr()); return ret;
return htonl(inet_addr(cp.get_ptr())); // return a big-endian IP address }
}
int inet_aton() s32 shutdown(s32 s, s32 how)
{ {
UNIMPLEMENTED_FUNC(sys_net); sys_net.Warning("shutdown(s=%d, how=%d)", s, how);
return CELL_OK; int ret = ::shutdown(s, how);
} *g_lastError = getLastError();
return ret;
}
int inet_lnaof() s32 socket(s32 family, s32 type, s32 protocol)
{ {
UNIMPLEMENTED_FUNC(sys_net); sys_net.Warning("socket(family=%d, type=%d, protocol=%d)", family, type, protocol);
return CELL_OK; int ret = ::socket(family, type, protocol);
} *g_lastError = getLastError();
return ret;
}
int inet_makeaddr() s32 socketclose(s32 s)
{ {
UNIMPLEMENTED_FUNC(sys_net); sys_net.Warning("socket(s=%d)", s);
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);
#ifdef _WIN32 #ifdef _WIN32
int ret = closesocket(s); int ret = ::closesocket(s);
#else #else
int ret = close(s); int ret = ::close(s);
#endif #endif
*g_lastError = getLastError(); *g_lastError = getLastError();
return ret; return ret;
}
s32 socketpoll()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
s32 socketselect()
{
UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK;
}
} }
int socketpoll() s32 sys_net_initialize_network_ex(vm::ptr<sys_net_initialize_parameter> param)
{
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)
{ {
sys_net.Warning("sys_net_initialize_network_ex(param_addr=0x%x)", param.addr()); 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)); g_lastError = vm::ptr<s32>::make((u32)Memory.Alloc(4, 1));
#ifdef _WIN32 #ifdef _WIN32
WSADATA wsaData; WSADATA wsaData;
WORD wVersionRequested = MAKEWORD(1,1); WORD wVersionRequested = MAKEWORD(1, 1);
WSAStartup(wVersionRequested, &wsaData); WSAStartup(wVersionRequested, &wsaData);
#endif #endif
return CELL_OK; return CELL_OK;
} }
int sys_net_get_udpp2p_test_param() s32 sys_net_get_udpp2p_test_param()
{ {
UNIMPLEMENTED_FUNC(sys_net); UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK; return CELL_OK;
} }
int sys_net_set_udpp2p_test_param() s32 sys_net_set_udpp2p_test_param()
{ {
UNIMPLEMENTED_FUNC(sys_net); UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK; return CELL_OK;
} }
int sys_net_get_lib_name_server() s32 sys_net_get_lib_name_server()
{ {
UNIMPLEMENTED_FUNC(sys_net); UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK; return CELL_OK;
} }
int sys_net_if_ctl() s32 sys_net_if_ctl()
{ {
UNIMPLEMENTED_FUNC(sys_net); UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK; return CELL_OK;
} }
int sys_net_get_netemu_test_param() s32 sys_net_get_netemu_test_param()
{ {
UNIMPLEMENTED_FUNC(sys_net); UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK; return CELL_OK;
} }
int sys_net_get_sockinfo() s32 sys_net_get_sockinfo()
{ {
UNIMPLEMENTED_FUNC(sys_net); UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK; return CELL_OK;
} }
int sys_net_close_dump() s32 sys_net_close_dump()
{ {
UNIMPLEMENTED_FUNC(sys_net); UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK; return CELL_OK;
} }
int sys_net_set_test_param() s32 sys_net_set_test_param()
{ {
UNIMPLEMENTED_FUNC(sys_net); UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK; return CELL_OK;
} }
int sys_net_show_nameserver() s32 sys_net_show_nameserver()
{ {
UNIMPLEMENTED_FUNC(sys_net); UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK; return CELL_OK;
@ -410,67 +414,67 @@ u32 _sys_net_errno_loc()
return g_lastError.addr(); return g_lastError.addr();
} }
int sys_net_set_resolver_configurations() s32 sys_net_set_resolver_configurations()
{ {
UNIMPLEMENTED_FUNC(sys_net); UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK; return CELL_OK;
} }
int sys_net_show_route() s32 sys_net_show_route()
{ {
UNIMPLEMENTED_FUNC(sys_net); UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK; return CELL_OK;
} }
int sys_net_read_dump() s32 sys_net_read_dump()
{ {
UNIMPLEMENTED_FUNC(sys_net); UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK; return CELL_OK;
} }
int sys_net_abort_resolver() s32 sys_net_abort_resolver()
{ {
UNIMPLEMENTED_FUNC(sys_net); UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK; return CELL_OK;
} }
int sys_net_abort_socket() s32 sys_net_abort_socket()
{ {
UNIMPLEMENTED_FUNC(sys_net); UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK; return CELL_OK;
} }
int sys_net_set_lib_name_server() s32 sys_net_set_lib_name_server()
{ {
UNIMPLEMENTED_FUNC(sys_net); UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK; return CELL_OK;
} }
int sys_net_get_test_param() s32 sys_net_get_test_param()
{ {
UNIMPLEMENTED_FUNC(sys_net); UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK; return CELL_OK;
} }
int sys_net_get_sockinfo_ex() s32 sys_net_get_sockinfo_ex()
{ {
UNIMPLEMENTED_FUNC(sys_net); UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK; return CELL_OK;
} }
int sys_net_open_dump() s32 sys_net_open_dump()
{ {
UNIMPLEMENTED_FUNC(sys_net); UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK; return CELL_OK;
} }
int sys_net_show_ifconfig() s32 sys_net_show_ifconfig()
{ {
UNIMPLEMENTED_FUNC(sys_net); UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK; return CELL_OK;
} }
int sys_net_finalize_network() s32 sys_net_finalize_network()
{ {
sys_net.Warning("sys_net_initialize_network_ex()"); sys_net.Warning("sys_net_initialize_network_ex()");
Memory.Free(g_lastError.addr()); Memory.Free(g_lastError.addr());
@ -481,59 +485,59 @@ int sys_net_finalize_network()
return CELL_OK; return CELL_OK;
} }
int _sys_net_h_errno_loc() s32 _sys_net_h_errno_loc()
{ {
UNIMPLEMENTED_FUNC(sys_net); UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK; return CELL_OK;
} }
int sys_net_set_netemu_test_param() s32 sys_net_set_netemu_test_param()
{ {
UNIMPLEMENTED_FUNC(sys_net); UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK; return CELL_OK;
} }
int sys_net_free_thread_context() s32 sys_net_free_thread_context()
{ {
UNIMPLEMENTED_FUNC(sys_net); UNIMPLEMENTED_FUNC(sys_net);
return CELL_OK; 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", []() Module sys_net("sys_net", []()
{ {
// The names of the following functions are modified to avoid overloading problems REG_FUNC_(accept);
REG_FUNC(sys_net, sys_net_accept); REG_FUNC_(bind);
REG_FUNC(sys_net, sys_net_bind); REG_FUNC_(connect);
REG_FUNC(sys_net, sys_net_connect); REG_FUNC_(gethostbyaddr);
//REG_FUNC(sys_net, sys_net_gethostbyaddr); REG_FUNC_(gethostbyname);
//REG_FUNC(sys_net, sys_net_gethostbyname); REG_FUNC_(getpeername);
//REG_FUNC(sys_net, sys_net_getpeername); REG_FUNC_(getsockname);
//REG_FUNC(sys_net, sys_net_getsockname); REG_FUNC_(getsockopt);
//REG_FUNC(sys_net, sys_net_getsockopt); REG_FUNC_(inet_addr);
REG_FUNC(sys_net, sys_net_inet_addr); REG_FUNC_(inet_aton);
//REG_FUNC(sys_net, sys_net_inet_aton); REG_FUNC_(inet_lnaof);
//REG_FUNC(sys_net, sys_net_inet_lnaof); REG_FUNC_(inet_makeaddr);
//REG_FUNC(sys_net, sys_net_inet_makeaddr); REG_FUNC_(inet_netof);
//REG_FUNC(sys_net, sys_net_inet_netof); REG_FUNC_(inet_network);
//REG_FUNC(sys_net, sys_net_inet_network); REG_FUNC_(inet_ntoa);
//REG_FUNC(sys_net, sys_net_inet_ntoa); REG_FUNC_(inet_ntop);
//REG_FUNC(sys_net, sys_net_inet_ntop); REG_FUNC_(inet_pton);
REG_FUNC(sys_net, sys_net_inet_pton); REG_FUNC_(listen);
REG_FUNC(sys_net, sys_net_listen); REG_FUNC_(recv);
//sys_net.AddFunc(, sys_net_ntohl); REG_FUNC_(recvfrom);
//sys_net.AddFunc(, sys_net_ntohs); REG_FUNC_(recvmsg);
REG_FUNC(sys_net, sys_net_recv); REG_FUNC_(send);
REG_FUNC(sys_net, sys_net_recvfrom); REG_FUNC_(sendmsg);
//REG_FUNC(sys_net, sys_net_recvmsg); REG_FUNC_(sendto);
REG_FUNC(sys_net, sys_net_send); REG_FUNC_(setsockopt);
//REG_FUNC(sys_net, sys_net_sendmsg); REG_FUNC_(shutdown);
REG_FUNC(sys_net, sys_net_sendto); REG_FUNC_(socket);
REG_FUNC(sys_net, sys_net_setsockopt); REG_FUNC_(socketclose);
REG_FUNC(sys_net, sys_net_shutdown); REG_FUNC_(socketpoll);
REG_FUNC(sys_net, sys_net_socket); REG_FUNC_(socketselect);
REG_FUNC(sys_net, sys_net_socketclose);
//REG_FUNC(sys_net, sys_net_socketpoll);
//REG_FUNC(sys_net, sys_net_socketselect);
REG_FUNC(sys_net, sys_net_initialize_network_ex); REG_FUNC(sys_net, sys_net_initialize_network_ex);
REG_FUNC(sys_net, sys_net_get_udpp2p_test_param); REG_FUNC(sys_net, sys_net_get_udpp2p_test_param);

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

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