piwalker/dolphin
1
0
Fork 0
mirror of https://github.com/dolphin-emu/dolphin.git synced 2024-11-15 13:57:57 -07:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #5043 from lioncash/net

Browse Source 
IOS/Network/IP/Top: Separate behaviors into their own functions
This commit is contained in:
Matthew Parlane 2017-03-12 16:12:43 +13:00 committed by GitHub
commit d042121ebd
2 changed files with 815 additions and 748 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

340
Source/Core/Core/IOS/Network/IP/Top.cpp
View File

@ -155,81 +155,157 @@ IPCCommandResult NetIPTop::IOCtl(const IOCtlRequest& request)
return GetDefaultReply(IPC_EACCES);
}
s32 return_value = 0;
switch (request.request)
{
case IOCTL_SO_STARTUP:
{
request.Log(GetDeviceName(), LogTypes::IOS_WC24);
return StartUp(request);
case IOCTL_SO_SOCKET:
return Socket(request);
case IOCTL_SO_ICMPSOCKET:
return ICMPSocket(request);
case IOCTL_SO_CLOSE:
case IOCTL_SO_ICMPCLOSE:
return Close(request);
case IOCTL_SO_ACCEPT:
case IOCTL_SO_BIND:
case IOCTL_SO_CONNECT:
case IOCTL_SO_FCNTL:
return DoSock(request);
case IOCTL_SO_SHUTDOWN:
return Shutdown(request);
case IOCTL_SO_LISTEN:
return Listen(request);
case IOCTL_SO_GETSOCKOPT:
return GetSockOpt(request);
case IOCTL_SO_SETSOCKOPT:
return SetSockOpt(request);
case IOCTL_SO_GETSOCKNAME:
return GetSockName(request);
case IOCTL_SO_GETPEERNAME:
return GetPeerName(request);
case IOCTL_SO_GETHOSTID:
return GetHostID(request);
case IOCTL_SO_INETATON:
return InetAToN(request);
case IOCTL_SO_INETPTON:
return InetPToN(request);
case IOCTL_SO_INETNTOP:
return InetNToP(request);
case IOCTL_SO_POLL:
return Poll(request);
case IOCTL_SO_GETHOSTBYNAME:
return GetHostByName(request);
case IOCTL_SO_ICMPCANCEL:
return ICMPCancel(request);
default:
request.DumpUnknown(GetDeviceName(), LogTypes::IOS_NET);
break;
}
case IOCTL_SO_SOCKET:
return GetDefaultReply(IPC_SUCCESS);
}
IPCCommandResult NetIPTop::IOCtlV(const IOCtlVRequest& request)
{
switch (request.request)
{
case IOCTLV_SO_GETINTERFACEOPT:
return GetInterfaceOpt(request);
case IOCTLV_SO_SENDTO:
return SendTo(request);
case IOCTLV_SO_RECVFROM:
return RecvFrom(request);
case IOCTLV_SO_GETADDRINFO:
return GetAddressInfo(request);
case IOCTLV_SO_ICMPPING:
return ICMPPing(request);
default:
request.DumpUnknown(GetDeviceName(), LogTypes::IOS_NET);
break;
}
return GetDefaultReply(IPC_SUCCESS);
}
void NetIPTop::Update()
{
WiiSockMan::GetInstance().Update();
}
IPCCommandResult NetIPTop::StartUp(const IOCtlRequest& request)
{
request.Log(GetDeviceName(), LogTypes::IOS_WC24);
return GetDefaultReply(IPC_SUCCESS);
}
IPCCommandResult NetIPTop::Socket(const IOCtlRequest& request)
{
u32 af = Memory::Read_U32(request.buffer_in);
u32 type = Memory::Read_U32(request.buffer_in + 4);
u32 prot = Memory::Read_U32(request.buffer_in + 8);
WiiSockMan& sm = WiiSockMan::GetInstance();
return_value = sm.NewSocket(af, type, prot);
const s32 return_value = sm.NewSocket(af, type, prot);
INFO_LOG(IOS_NET, "IOCTL_SO_SOCKET "
"Socket: %08x (%d,%d,%d), BufferIn: (%08x, %i), BufferOut: (%08x, %i)",
return_value, af, type, prot, request.buffer_in, request.buffer_in_size,
request.buffer_out, request.buffer_out_size);
break;
return GetDefaultReply(return_value);
}
case IOCTL_SO_ICMPSOCKET:
IPCCommandResult NetIPTop::ICMPSocket(const IOCtlRequest& request)
{
u32 pf = Memory::Read_U32(request.buffer_in);
WiiSockMan& sm = WiiSockMan::GetInstance();
return_value = sm.NewSocket(pf, SOCK_RAW, IPPROTO_ICMP);
const s32 return_value = sm.NewSocket(pf, SOCK_RAW, IPPROTO_ICMP);
INFO_LOG(IOS_NET, "IOCTL_SO_ICMPSOCKET(%x) %d", pf, return_value);
break;
return GetDefaultReply(return_value);
}
case IOCTL_SO_CLOSE:
case IOCTL_SO_ICMPCLOSE:
IPCCommandResult NetIPTop::Close(const IOCtlRequest& request)
{
u32 fd = Memory::Read_U32(request.buffer_in);
WiiSockMan& sm = WiiSockMan::GetInstance();
return_value = sm.DeleteSocket(fd);
const s32 return_value = sm.DeleteSocket(fd);
INFO_LOG(IOS_NET, "%s(%x) %x",
request.request == IOCTL_SO_ICMPCLOSE ? "IOCTL_SO_ICMPCLOSE" : "IOCTL_SO_CLOSE", fd,
return_value);
break;
return GetDefaultReply(return_value);
}
case IOCTL_SO_ACCEPT:
case IOCTL_SO_BIND:
case IOCTL_SO_CONNECT:
case IOCTL_SO_FCNTL:
IPCCommandResult NetIPTop::DoSock(const IOCtlRequest& request)
{
u32 fd = Memory::Read_U32(request.buffer_in);
WiiSockMan& sm = WiiSockMan::GetInstance();
sm.DoSock(fd, request, static_cast<NET_IOCTL>(request.request));
return GetNoReply();
}
/////////////////////////////////////////////////////////////
// TODO: Tidy all below //
/////////////////////////////////////////////////////////////
case IOCTL_SO_SHUTDOWN:
IPCCommandResult NetIPTop::Shutdown(const IOCtlRequest& request)
{
request.Log(GetDeviceName(), LogTypes::IOS_WC24);
u32 fd = Memory::Read_U32(request.buffer_in);
u32 how = Memory::Read_U32(request.buffer_in + 4);
int ret = shutdown(fd, how);
return_value = WiiSockMan::GetNetErrorCode(ret, "SO_SHUTDOWN", false);
break;
return GetDefaultReply(WiiSockMan::GetNetErrorCode(ret, "SO_SHUTDOWN", false));
}
case IOCTL_SO_LISTEN:
IPCCommandResult NetIPTop::Listen(const IOCtlRequest& request)
{
u32 fd = Memory::Read_U32(request.buffer_in);
u32 BACKLOG = Memory::Read_U32(request.buffer_in + 0x04);
u32 ret = listen(fd, BACKLOG);
return_value = WiiSockMan::GetNetErrorCode(ret, "SO_LISTEN", false);
request.Log(GetDeviceName(), LogTypes::IOS_WC24);
break;
return GetDefaultReply(WiiSockMan::GetNetErrorCode(ret, "SO_LISTEN", false));
}
case IOCTL_SO_GETSOCKOPT:
IPCCommandResult NetIPTop::GetSockOpt(const IOCtlRequest& request)
{
u32 fd = Memory::Read_U32(request.buffer_out);
u32 level = Memory::Read_U32(request.buffer_out + 4);
@ -245,7 +321,7 @@ IPCCommandResult NetIPTop::IOCtl(const IOCtlRequest& request)
u32 optlen = 4;
int ret = getsockopt(fd, nat_level, nat_optname, (char*)&optval, (socklen_t*)&optlen);
return_value = WiiSockMan::GetNetErrorCode(ret, "SO_GETSOCKOPT", false);
const s32 return_value = WiiSockMan::GetNetErrorCode(ret, "SO_GETSOCKOPT", false);
Memory::Write_U32(optlen, request.buffer_out + 0xC);
Memory::CopyToEmu(request.buffer_out + 0x10, optval, optlen);
@ -257,10 +333,11 @@ IPCCommandResult NetIPTop::IOCtl(const IOCtlRequest& request)
Memory::Write_U32(sizeof(s32), request.buffer_out + 0xC);
Memory::Write_U32(last_error, request.buffer_out + 0x10);
}
break;
return GetDefaultReply(return_value);
}
case IOCTL_SO_SETSOCKOPT:
IPCCommandResult NetIPTop::SetSockOpt(const IOCtlRequest& request)
{
u32 fd = Memory::Read_U32(request.buffer_in);
u32 level = Memory::Read_U32(request.buffer_in + 4);
@ -275,36 +352,32 @@ IPCCommandResult NetIPTop::IOCtl(const IOCtlRequest& request)
"%02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx "
"%02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx",
fd, level, optname, optlen, request.buffer_in, request.buffer_in_size,
request.buffer_out, request.buffer_out_size, optval[0], optval[1], optval[2],
optval[3], optval[4], optval[5], optval[6], optval[7], optval[8], optval[9],
optval[10], optval[11], optval[12], optval[13], optval[14], optval[15], optval[16],
optval[17], optval[18], optval[19]);
request.buffer_out, request.buffer_out_size, optval[0], optval[1], optval[2], optval[3],
optval[4], optval[5], optval[6], optval[7], optval[8], optval[9], optval[10], optval[11],
optval[12], optval[13], optval[14], optval[15], optval[16], optval[17], optval[18],
optval[19]);
// TODO: bug booto about this, 0x2005 most likely timeout related, default value on Wii is ,
// 0x2001 is most likely tcpnodelay
if (level == 6 && (optname == 0x2005 || optname == 0x2001))
{
return_value = 0;
break;
}
return GetDefaultReply(0);
// Do the level/optname translation
int nat_level = MapWiiSockOptLevelToNative(level);
int nat_optname = MapWiiSockOptNameToNative(optname);
int ret = setsockopt(fd, nat_level, nat_optname, (char*)optval, optlen);
return_value = WiiSockMan::GetNetErrorCode(ret, "SO_SETSOCKOPT", false);
break;
return GetDefaultReply(WiiSockMan::GetNetErrorCode(ret, "SO_SETSOCKOPT", false));
}
case IOCTL_SO_GETSOCKNAME:
IPCCommandResult NetIPTop::GetSockName(const IOCtlRequest& request)
{
u32 fd = Memory::Read_U32(request.buffer_in);
request.Log(GetDeviceName(), LogTypes::IOS_WC24);
sockaddr sa;
socklen_t sa_len;
sa_len = sizeof(sa);
socklen_t sa_len = sizeof(sa);
int ret = getsockname(fd, &sa, &sa_len);
if (request.buffer_out_size < 2 + sizeof(sa.sa_data))
@ -315,19 +388,20 @@ IPCCommandResult NetIPTop::IOCtl(const IOCtlRequest& request)
if (request.buffer_out_size > 1)
Memory::Write_U8(sa.sa_family & 0xFF, request.buffer_out + 1);
if (request.buffer_out_size > 2)
{
Memory::CopyToEmu(request.buffer_out + 2, &sa.sa_data,
std::min<size_t>(sizeof(sa.sa_data), request.buffer_out_size - 2));
return_value = ret;
break;
}
case IOCTL_SO_GETPEERNAME:
return GetDefaultReply(ret);
}
IPCCommandResult NetIPTop::GetPeerName(const IOCtlRequest& request)
{
u32 fd = Memory::Read_U32(request.buffer_in);
sockaddr sa;
socklen_t sa_len;
sa_len = sizeof(sa);
socklen_t sa_len = sizeof(sa);
int ret = getpeername(fd, &sa, &sa_len);
if (request.buffer_out_size < 2 + sizeof(sa.sa_data))
@ -338,19 +412,21 @@ IPCCommandResult NetIPTop::IOCtl(const IOCtlRequest& request)
if (request.buffer_out_size > 1)
Memory::Write_U8(AF_INET, request.buffer_out + 1);
if (request.buffer_out_size > 2)
{
Memory::CopyToEmu(request.buffer_out + 2, &sa.sa_data,
std::min<size_t>(sizeof(sa.sa_data), request.buffer_out_size - 2));
INFO_LOG(IOS_NET, "IOCTL_SO_GETPEERNAME(%x)", fd);
return_value = ret;
break;
}
case IOCTL_SO_GETHOSTID:
INFO_LOG(IOS_NET, "IOCTL_SO_GETPEERNAME(%x)", fd);
return GetDefaultReply(ret);
}
IPCCommandResult NetIPTop::GetHostID(const IOCtlRequest& request)
{
request.Log(GetDeviceName(), LogTypes::IOS_WC24);
s32 return_value = 0;
#ifdef _WIN32
DWORD forwardTableSize, ipTableSize, result;
DWORD ifIndex = -1;
@ -372,8 +448,8 @@ IPCCommandResult NetIPTop::IOCtl(const IOCtlRequest& request)
// find the interface IP used for the default route and use that
result = GetIpForwardTable(forwardTable.get(), &forwardTableSize, FALSE);
while (result == NO_ERROR ||
result == ERROR_MORE_DATA) // can return ERROR_MORE_DATA on XP even after the first call
// can return ERROR_MORE_DATA on XP even after the first call
while (result == NO_ERROR || result == ERROR_MORE_DATA)
{
for (DWORD i = 0; i < forwardTable->dwNumEntries; ++i)
{
@ -406,10 +482,11 @@ IPCCommandResult NetIPTop::IOCtl(const IOCtlRequest& request)
// default placeholder, in case of failure
if (return_value == 0)
return_value = 192 << 24 | 168 << 16 | 1 << 8 | 150;
break;
return GetDefaultReply(return_value);
}
case IOCTL_SO_INETATON:
IPCCommandResult NetIPTop::InetAToN(const IOCtlRequest& request)
{
std::string hostname = Memory::GetString(request.buffer_in);
struct hostent* remoteHost = gethostbyname(hostname.c_str());
@ -421,45 +498,41 @@ IPCCommandResult NetIPTop::IOCtl(const IOCtlRequest& request)
"%s, BufferIn: (%08x, %i), BufferOut: (%08x, %i), IP Found: None",
hostname.c_str(), request.buffer_in, request.buffer_in_size, request.buffer_out,
request.buffer_out_size);
return_value = 0;
return GetDefaultReply(0);
}
else
{
Memory::Write_U32(Common::swap32(*(u32*)remoteHost->h_addr_list[0]), request.buffer_out);
INFO_LOG(IOS_NET, "IOCTL_SO_INETATON = 0 "
"%s, BufferIn: (%08x, %i), BufferOut: (%08x, %i), IP Found: %08X",
hostname.c_str(), request.buffer_in, request.buffer_in_size, request.buffer_out,
request.buffer_out_size, Common::swap32(*(u32*)remoteHost->h_addr_list[0]));
return_value = 1;
}
break;
return GetDefaultReply(1);
}
case IOCTL_SO_INETPTON:
IPCCommandResult NetIPTop::InetPToN(const IOCtlRequest& request)
{
std::string address = Memory::GetString(request.buffer_in);
INFO_LOG(IOS_NET, "IOCTL_SO_INETPTON "
"(Translating: %s)",
address.c_str());
return_value = inet_pton(address.c_str(), Memory::GetPointer(request.buffer_out + 4));
break;
INFO_LOG(IOS_NET, "IOCTL_SO_INETPTON (Translating: %s)", address.c_str());
return GetDefaultReply(inet_pton(address.c_str(), Memory::GetPointer(request.buffer_out + 4)));
}
case IOCTL_SO_INETNTOP:
IPCCommandResult NetIPTop::InetNToP(const IOCtlRequest& request)
{
// u32 af = Memory::Read_U32(BufferIn);
// u32 validAddress = Memory::Read_U32(request.buffer_in + 4);
// u32 src = Memory::Read_U32(request.buffer_in + 8);
char ip_s[16];
sprintf(ip_s, "%i.%i.%i.%i", Memory::Read_U8(request.buffer_in + 8),
Memory::Read_U8(request.buffer_in + 8 + 1), Memory::Read_U8(request.buffer_in + 8 + 2),
Memory::Read_U8(request.buffer_in + 8 + 3));
INFO_LOG(IOS_NET, "IOCTL_SO_INETNTOP %s", ip_s);
Memory::CopyToEmu(request.buffer_out, (u8*)ip_s, strlen(ip_s));
break;
return GetDefaultReply(0);
}
case IOCTL_SO_POLL:
IPCCommandResult NetIPTop::Poll(const IOCtlRequest& request)
{
// Map Wii/native poll events types
struct
@ -525,21 +598,19 @@ IPCCommandResult NetIPTop::IOCtl(const IOCtlRequest& request)
// Memory::Write_U32(events, request.buffer_out + 0xc*i + 4); //events
Memory::Write_U32(revents, request.buffer_out + 0xc * i + 8); // revents
DEBUG_LOG(IOS_NET, "IOCTL_SO_POLL socket %d wevents %08X events %08X revents %08X", i,
revents, ufds[i].events, ufds[i].revents);
DEBUG_LOG(IOS_NET, "IOCTL_SO_POLL socket %d wevents %08X events %08X revents %08X", i, revents,
ufds[i].events, ufds[i].revents);
}
return_value = ret;
break;
return GetDefaultReply(ret);
}
case IOCTL_SO_GETHOSTBYNAME:
IPCCommandResult NetIPTop::GetHostByName(const IOCtlRequest& request)
{
if (request.buffer_out_size != 0x460)
{
ERROR_LOG(IOS_NET, "Bad buffer size for IOCTL_SO_GETHOSTBYNAME");
return_value = -1;
break;
return GetDefaultReply(-1);
}
std::string hostname = Memory::GetString(request.buffer_in);
@ -550,8 +621,9 @@ IPCCommandResult NetIPTop::IOCtl(const IOCtlRequest& request)
hostname.c_str(), request.buffer_in, request.buffer_in_size, request.buffer_out,
request.buffer_out_size);
if (remoteHost)
{
if (remoteHost == nullptr)
return GetDefaultReply(-1);
for (int i = 0; remoteHost->h_aliases[i]; ++i)
{
DEBUG_LOG(IOS_NET, "alias%i:%s", i, remoteHost->h_aliases[i]);
@ -560,8 +632,8 @@ IPCCommandResult NetIPTop::IOCtl(const IOCtlRequest& request)
for (int i = 0; remoteHost->h_addr_list[i]; ++i)
{
u32 ip = Common::swap32(*(u32*)(remoteHost->h_addr_list[i]));
std::string ip_s = StringFromFormat("%i.%i.%i.%i", ip >> 24, (ip >> 16) & 0xff,
(ip >> 8) & 0xff, ip & 0xff);
std::string ip_s =
StringFromFormat("%i.%i.%i.%i", ip >> 24, (ip >> 16) & 0xff, (ip >> 8) & 0xff, ip & 0xff);
DEBUG_LOG(IOS_NET, "addr%i:%s", i, ip_s.c_str());
}
@ -573,8 +645,7 @@ IPCCommandResult NetIPTop::IOCtl(const IOCtlRequest& request)
if (name_length > (GETHOSTBYNAME_IP_LIST_OFFSET - GETHOSTBYNAME_STRUCT_SIZE))
{
ERROR_LOG(IOS_NET, "Hostname too long in IOCTL_SO_GETHOSTBYNAME");
return_value = -1;
break;
return GetDefaultReply(-1);
}
Memory::CopyToEmu(request.buffer_out + GETHOSTBYNAME_STRUCT_SIZE, remoteHost->h_name,
name_length);
@ -598,8 +669,7 @@ IPCCommandResult NetIPTop::IOCtl(const IOCtlRequest& request)
// This must be exact: PPC code to convert the struct hardcodes
// this offset.
static const u32 GETHOSTBYNAME_IP_PTR_LIST_OFFSET = 0x340;
Memory::Write_U32(request.buffer_out + GETHOSTBYNAME_IP_PTR_LIST_OFFSET,
request.buffer_out + 12);
Memory::Write_U32(request.buffer_out + GETHOSTBYNAME_IP_PTR_LIST_OFFSET, request.buffer_out + 12);
for (u32 i = 0; i < num_ip_addr; ++i)
{
u32 addr = request.buffer_out + GETHOSTBYNAME_IP_PTR_LIST_OFFSET + i * 4;
@ -612,45 +682,28 @@ IPCCommandResult NetIPTop::IOCtl(const IOCtlRequest& request)
request.buffer_out + 4);
// Returned struct must be ipv4.
_assert_msg_(IOS_NET,
remoteHost->h_addrtype == AF_INET && remoteHost->h_length == sizeof(u32),
_assert_msg_(IOS_NET, remoteHost->h_addrtype == AF_INET && remoteHost->h_length == sizeof(u32),
"returned host info is not IPv4");
Memory::Write_U16(AF_INET, request.buffer_out + 8);
Memory::Write_U16(sizeof(u32), request.buffer_out + 10);
return_value = 0;
return GetDefaultReply(0);
}
else
IPCCommandResult NetIPTop::ICMPCancel(const IOCtlRequest& request)
{
return_value = -1;
}
break;
}
case IOCTL_SO_ICMPCANCEL:
ERROR_LOG(IOS_NET, "IOCTL_SO_ICMPCANCEL");
default:
request.DumpUnknown(GetDeviceName(), LogTypes::IOS_NET);
return GetDefaultReply(0);
}
return GetDefaultReply(return_value);
}
IPCCommandResult NetIPTop::GetInterfaceOpt(const IOCtlVRequest& request)
{
const u32 param = Memory::Read_U32(request.in_vectors[0].address);
const u32 param2 = Memory::Read_U32(request.in_vectors[0].address + 4);
const u32 param3 = Memory::Read_U32(request.io_vectors[0].address);
const u32 param4 = Memory::Read_U32(request.io_vectors[1].address);
u32 param5 = 0;
IPCCommandResult NetIPTop::IOCtlV(const IOCtlVRequest& request)
{
s32 return_value = 0;
u32 param = 0, param2 = 0, param3, param4, param5 = 0;
switch (request.request)
{
case IOCTLV_SO_GETINTERFACEOPT:
{
param = Memory::Read_U32(request.in_vectors[0].address);
param2 = Memory::Read_U32(request.in_vectors[0].address + 4);
param3 = Memory::Read_U32(request.io_vectors[0].address);
param4 = Memory::Read_U32(request.io_vectors[1].address);
if (request.io_vectors[0].size >= 8)
{
param5 = Memory::Read_U32(request.io_vectors[0].address + 4);
@ -709,13 +762,11 @@ IPCCommandResult NetIPTop::IOCtlV(const IOCtlVRequest& request)
AdapterList->OperStatus == IfOperStatusUp)
{
INFO_LOG(IOS_NET, "Name of valid interface: %S", AdapterList->FriendlyName);
INFO_LOG(IOS_NET, "DNS: %u.%u.%u.%u",
(unsigned char)
AdapterList->FirstDnsServerAddress->Address.lpSockaddr->sa_data[2],
(unsigned char)
AdapterList->FirstDnsServerAddress->Address.lpSockaddr->sa_data[3],
(unsigned char)
AdapterList->FirstDnsServerAddress->Address.lpSockaddr->sa_data[4],
INFO_LOG(
IOS_NET, "DNS: %u.%u.%u.%u",
(unsigned char)AdapterList->FirstDnsServerAddress->Address.lpSockaddr->sa_data[2],
(unsigned char)AdapterList->FirstDnsServerAddress->Address.lpSockaddr->sa_data[3],
(unsigned char)AdapterList->FirstDnsServerAddress->Address.lpSockaddr->sa_data[4],
(unsigned char)
AdapterList->FirstDnsServerAddress->Address.lpSockaddr->sa_data[5]);
address = Common::swap32(
@ -768,25 +819,27 @@ IPCCommandResult NetIPTop::IOCtlV(const IOCtlVRequest& request)
ERROR_LOG(IOS_NET, "Unknown param2: %08X", param2);
break;
}
break;
return GetDefaultReply(0);
}
case IOCTLV_SO_SENDTO:
IPCCommandResult NetIPTop::SendTo(const IOCtlVRequest& request)
{
u32 fd = Memory::Read_U32(request.in_vectors[1].address);
WiiSockMan& sm = WiiSockMan::GetInstance();
sm.DoSock(fd, request, IOCTLV_SO_SENDTO);
return GetNoReply();
break;
}
case IOCTLV_SO_RECVFROM:
IPCCommandResult NetIPTop::RecvFrom(const IOCtlVRequest& request)
{
u32 fd = Memory::Read_U32(request.in_vectors[0].address);
WiiSockMan& sm = WiiSockMan::GetInstance();
sm.DoSock(fd, request, IOCTLV_SO_RECVFROM);
return GetNoReply();
break;
}
case IOCTLV_SO_GETADDRINFO:
IPCCommandResult NetIPTop::GetAddressInfo(const IOCtlVRequest& request)
{
addrinfo hints;
@ -828,8 +881,7 @@ IPCCommandResult NetIPTop::IOCtlV(const IOCtlVRequest& request)
u32 sockoffset = addr + 0x460;
if (ret == 0)
{
for (addrinfo* result_iter = result; result_iter != nullptr;
result_iter = result_iter->ai_next)
for (addrinfo* result_iter = result; result_iter != nullptr; result_iter = result_iter->ai_next)
{
Memory::Write_U32(result_iter->ai_flags, addr);
Memory::Write_U32(result_iter->ai_family, addr + 0x04);
@ -875,10 +927,10 @@ IPCCommandResult NetIPTop::IOCtlV(const IOCtlVRequest& request)
}
request.Dump(GetDeviceName(), LogTypes::IOS_NET, LogTypes::LINFO);
return_value = ret;
break;
return GetDefaultReply(ret);
}
case IOCTLV_SO_ICMPPING:
IPCCommandResult NetIPTop::ICMPPing(const IOCtlVRequest& request)
{
struct
{
@ -921,7 +973,9 @@ IPCCommandResult NetIPTop::IOCtlV(const IOCtlVRequest& request)
s32 icmp_length = sizeof(data);
if (request.in_vectors.size() > 1 && request.in_vectors[1].size == sizeof(data))
{
Memory::CopyFromEmu(data, request.in_vectors[1].address, request.in_vectors[1].size);
}
else
{
// TODO sequence number is incremented either statically, by
@ -938,19 +992,7 @@ IPCCommandResult NetIPTop::IOCtlV(const IOCtlVRequest& request)
}
// TODO proper error codes
return_value = 0;
break;
}
default:
request.DumpUnknown(GetDeviceName(), LogTypes::IOS_NET);
}
return GetDefaultReply(return_value);
}
void NetIPTop::Update()
{
WiiSockMan::GetInstance().Update();
return GetDefaultReply(0);
}
} // namespace Device
} // namespace HLE

25
Source/Core/Core/IOS/Network/IP/Top.h
View File

@ -70,6 +70,31 @@ public:
void Update() override;
private:
IPCCommandResult StartUp(const IOCtlRequest& request);
IPCCommandResult Socket(const IOCtlRequest& request);
IPCCommandResult ICMPSocket(const IOCtlRequest& request);
IPCCommandResult Close(const IOCtlRequest& request);
IPCCommandResult DoSock(const IOCtlRequest& request);
IPCCommandResult Shutdown(const IOCtlRequest& request);
IPCCommandResult Listen(const IOCtlRequest& request);
IPCCommandResult GetSockOpt(const IOCtlRequest& request);
IPCCommandResult SetSockOpt(const IOCtlRequest& request);
IPCCommandResult GetSockName(const IOCtlRequest& request);
IPCCommandResult GetPeerName(const IOCtlRequest& request);
IPCCommandResult GetHostID(const IOCtlRequest& request);
IPCCommandResult InetAToN(const IOCtlRequest& request);
IPCCommandResult InetPToN(const IOCtlRequest& request);
IPCCommandResult InetNToP(const IOCtlRequest& request);
IPCCommandResult Poll(const IOCtlRequest& request);
IPCCommandResult GetHostByName(const IOCtlRequest& request);
IPCCommandResult ICMPCancel(const IOCtlRequest& request);
IPCCommandResult GetInterfaceOpt(const IOCtlVRequest& request);
IPCCommandResult SendTo(const IOCtlVRequest& request);
IPCCommandResult RecvFrom(const IOCtlVRequest& request);
IPCCommandResult GetAddressInfo(const IOCtlVRequest& request);
IPCCommandResult ICMPPing(const IOCtlVRequest& request);
#ifdef _WIN32
WSADATA InitData;
#endif