ShuriZma
/
xenia-canary
mirror of https://github.com/xenia-canary/xenia-canary.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #247 from DrChat/xnet_callerid 

Discovered NetDll functions' first argument and fix XNetDebugXnAddr signature
This commit is contained in:
Ben Vanik 2015-06-06 20:54:18 -07:00
parent cc79934fee 14b14f4309
commit 6f4049ac0f
1 changed files with 103 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

176
src/xenia/kernel/xam_net.cc
View File

@ -20,6 +20,26 @@
namespace xe {
namespace kernel {
// https://github.com/G91/TitanOffLine/blob/1e692d9bb9dfac386d08045ccdadf4ae3227bb5e/xkelib/xam/xamNet.h
enum {
XNCALLER_INVALID = 0x0,
XNCALLER_TITLE = 0x1,
XNCALLER_SYSAPP = 0x2,
XNCALLER_XBDM = 0x3,
XNCALLER_TEST = 0x4,
NUM_XNCALLER_TYPES = 0x4,
};
// https://github.com/pmrowla/hl2sdk-csgo/blob/master/common/xbox/xboxstubs.h
typedef struct {
// FYI: IN_ADDR should be in network-byte order.
IN_ADDR ina; // IP address (zero if not static/DHCP)
IN_ADDR inaOnline; // Online IP address (zero if not online)
xe::be<uint16_t> wPortOnline; // Online port
uint8_t abEnet[6]; // Ethernet MAC address
uint8_t abOnline[20]; // Online identification
} XNADDR;
void LoadSockaddr(const uint8_t* ptr, sockaddr* out_addr) {
out_addr->sa_family = xe::load_and_swap<uint16_t>(ptr + 0);
switch (out_addr->sa_family) {
@ -76,10 +96,10 @@ XNetStartupParams xnet_startup_params = {0};
SHIM_CALL NetDll_XNetStartup_shim(PPCContext* ppc_context,
KernelState* kernel_state) {
uint32_t arg0 = SHIM_GET_ARG_32(0);
uint32_t caller = SHIM_GET_ARG_32(0);
uint32_t params_ptr = SHIM_GET_ARG_32(1);
XELOGD("NetDll_XNetStartup(%d, %.8X)", arg0, params_ptr);
XELOGD("NetDll_XNetStartup(%d, %.8X)", caller, params_ptr);
if (params_ptr) {
auto params =
@ -93,22 +113,14 @@ SHIM_CALL NetDll_XNetStartup_shim(PPCContext* ppc_context,
SHIM_CALL NetDll_XNetCleanup_shim(PPCContext* ppc_context,
KernelState* kernel_state) {
uint32_t arg0 = SHIM_GET_ARG_32(0);
uint32_t caller = SHIM_GET_ARG_32(0);
uint32_t params_ptr = SHIM_GET_ARG_32(1);
XELOGD("NetDll_XNetCleanup(%d, %.8X)", arg0, params_ptr);
XELOGD("NetDll_XNetCleanup(%d, %.8X)", caller, params_ptr);
SHIM_SET_RETURN_32(0);
}
dword_result_t NetDll_XNetGetDebugXnAddr(lpunknown_t out_address) {
out_address.Zero(36);
// 1 causes caller to gracefully return.
return 1;
}
DECLARE_XAM_EXPORT(NetDll_XNetGetDebugXnAddr,
ExportTag::kNetworking | ExportTag::kStub);
dword_result_t NetDll_XNetGetOpt(dword_t one, dword_t option_id,
lpvoid_t buffer_ptr, lpdword_t buffer_size) {
assert_true(one == 1);
@ -129,11 +141,11 @@ DECLARE_XAM_EXPORT(NetDll_XNetGetOpt, ExportTag::kNetworking);
SHIM_CALL NetDll_XNetRandom_shim(PPCContext* ppc_context,
KernelState* kernel_state) {
uint32_t arg0 = SHIM_GET_ARG_32(0);
uint32_t caller = SHIM_GET_ARG_32(0);
uint32_t buffer_ptr = SHIM_GET_ARG_32(1);
uint32_t length = SHIM_GET_ARG_32(2);
XELOGD("NetDll_XNetRandom(%d, %.8X, %d)", arg0, buffer_ptr, length);
XELOGD("NetDll_XNetRandom(%d, %.8X, %d)", caller, buffer_ptr, length);
// For now, constant values.
// This makes replicating things easier.
@ -144,11 +156,11 @@ SHIM_CALL NetDll_XNetRandom_shim(PPCContext* ppc_context,
SHIM_CALL NetDll_WSAStartup_shim(PPCContext* ppc_context,
KernelState* kernel_state) {
uint32_t arg0 = SHIM_GET_ARG_32(0); // always 1?
uint32_t caller = SHIM_GET_ARG_32(0);
uint32_t version = SHIM_GET_ARG_16(1);
uint32_t data_ptr = SHIM_GET_ARG_32(2);
XELOGD("NetDll_WSAStartup(%d, %.4X, %.8X)", arg0, version, data_ptr);
XELOGD("NetDll_WSAStartup(%d, %.4X, %.8X)", caller, version, data_ptr);
// TODO: Abstraction layer needed
WSADATA wsaData;
@ -176,9 +188,9 @@ SHIM_CALL NetDll_WSAStartup_shim(PPCContext* ppc_context,
SHIM_CALL NetDll_WSACleanup_shim(PPCContext* ppc_context,
KernelState* kernel_state) {
uint32_t arg0 = SHIM_GET_ARG_32(0);
uint32_t caller = SHIM_GET_ARG_32(0);
XELOGD("NetDll_WSACleanup(%d)", arg0);
XELOGD("NetDll_WSACleanup(%d)", caller);
int ret = WSACleanup();
SHIM_SET_RETURN_32(ret);
@ -192,53 +204,72 @@ SHIM_CALL NetDll_WSAGetLastError_shim(PPCContext* ppc_context,
SHIM_SET_RETURN_32(err);
}
// typedef struct {
// IN_ADDR ina; // IP address (zero if not
// static/DHCP)
// IN_ADDR inaOnline; // Online IP address (zero
// if not online)
// WORD wPortOnline; // Online port
// BYTE abEnet[6]; // Ethernet MAC address
// BYTE abOnline[20]; // Online identification
// } XNADDR;
struct XnAddrStatus {
// Address acquisition is not yet complete
const static uint32_t XNET_GET_XNADDR_PENDING = 0x00000000;
// XNet is uninitialized or no debugger found
const static uint32_t XNET_GET_XNADDR_NONE = 0x00000001;
// Host has ethernet address (no IP address)
const static uint32_t XNET_GET_XNADDR_ETHERNET = 0x00000002;
// Host has statically assigned IP address
const static uint32_t XNET_GET_XNADDR_STATIC = 0x00000004;
// Host has DHCP assigned IP address
const static uint32_t XNET_GET_XNADDR_DHCP = 0x00000008;
// Host has PPPoE assigned IP address
const static uint32_t XNET_GET_XNADDR_PPPOE = 0x00000010;
// Host has one or more gateways configured
const static uint32_t XNET_GET_XNADDR_GATEWAY = 0x00000020;
// Host has one or more DNS servers configured
const static uint32_t XNET_GET_XNADDR_DNS = 0x00000040;
// Host is currently connected to online service
const static uint32_t XNET_GET_XNADDR_ONLINE = 0x00000080;
// Network configuration requires troubleshooting
const static uint32_t XNET_GET_XNADDR_TROUBLESHOOT = 0x00008000;
};
SHIM_CALL NetDll_XNetGetTitleXnAddr_shim(PPCContext* ppc_context,
KernelState* kernel_state) {
uint32_t arg0 = SHIM_GET_ARG_32(0); // constant 1?
uint32_t addr_ptr = SHIM_GET_ARG_32(1); // XNADDR
dword_result_t NetDll_XNetGetTitleXnAddr(dword_t caller,
pointer_t<XNADDR> addr_ptr) {
// Just return a loopback address atm.
addr_ptr->ina.S_un.S_addr = htonl(INADDR_LOOPBACK);
addr_ptr->inaOnline.S_un.S_addr = 0;
addr_ptr->wPortOnline = 0;
std::memset(addr_ptr->abEnet, 0, 6);
std::memset(addr_ptr->abOnline, 0, 20);
XELOGD("NetDll_XNetGetTitleXnAddr(%d, %.8X)", arg0, addr_ptr);
auto addr = kernel_state->memory()->TranslateVirtual(addr_ptr);
xe::store<uint32_t>(addr + 0x0, htonl(INADDR_LOOPBACK));
xe::store_and_swap<uint32_t>(addr + 0x4, 0);
xe::store_and_swap<uint16_t>(addr + 0x8, 0);
std::memset(addr + 0xA, 0, 6);
std::memset(addr + 0x10, 0, 20);
SHIM_SET_RETURN_32(0x00000004); // XNET_GET_XNADDR_STATIC
return XnAddrStatus::XNET_GET_XNADDR_STATIC;
}
DECLARE_XAM_EXPORT(NetDll_XNetGetTitleXnAddr,
ExportTag::kNetworking | ExportTag::kStub);
dword_result_t NetDll_XNetGetDebugXnAddr(dword_t caller,
pointer_t<XNADDR> addr_ptr) {
addr_ptr.Zero();
// XNET_GET_XNADDR_NONE causes caller to gracefully return.
return XnAddrStatus::XNET_GET_XNADDR_NONE;
}
DECLARE_XAM_EXPORT(NetDll_XNetGetDebugXnAddr,
ExportTag::kNetworking | ExportTag::kStub);
SHIM_CALL NetDll_XNetGetEthernetLinkStatus_shim(PPCContext* ppc_context,
KernelState* kernel_state) {
// Games seem to call this before *Startup. If we return 0, they don't even
// try.
uint32_t arg0 = SHIM_GET_ARG_32(0);
uint32_t caller = SHIM_GET_ARG_32(0);
XELOGD("NetDll_XNetGetEthernetLinkStatus(%d)", arg0);
XELOGD("NetDll_XNetGetEthernetLinkStatus(%d)", caller);
SHIM_SET_RETURN_32(0);
}
SHIM_CALL NetDll_XNetQosServiceLookup_shim(PPCContext* ppc_context,
KernelState* kernel_state) {
uint32_t one = SHIM_GET_ARG_32(0);
uint32_t caller = SHIM_GET_ARG_32(0);
uint32_t zero = SHIM_GET_ARG_32(1);
uint32_t event_handle = SHIM_GET_ARG_32(2);
uint32_t out_ptr = SHIM_GET_ARG_32(3);
XELOGD("NetDll_XNetQosServiceLookup(%d, %d, %.8X, %.8X)", one, zero,
XELOGD("NetDll_XNetQosServiceLookup(%d, %d, %.8X, %.8X)", caller, zero,
event_handle, out_ptr);
// Non-zero is error.
@ -258,12 +289,12 @@ SHIM_CALL NetDll_inet_addr_shim(PPCContext* ppc_context,
SHIM_CALL NetDll_socket_shim(PPCContext* ppc_context,
KernelState* kernel_state) {
uint32_t arg0 = SHIM_GET_ARG_32(0);
uint32_t caller = SHIM_GET_ARG_32(0);
uint32_t af = SHIM_GET_ARG_32(1);
uint32_t type = SHIM_GET_ARG_32(2);
uint32_t protocol = SHIM_GET_ARG_32(3);
XELOGD("NetDll_socket(%d, %d, %d, %d)", arg0, af, type, protocol);
XELOGD("NetDll_socket(%d, %d, %d, %d)", caller, af, type, protocol);
if (protocol == 0xFE) {
protocol = IPPROTO_UDP;
}
@ -276,10 +307,10 @@ SHIM_CALL NetDll_socket_shim(PPCContext* ppc_context,
SHIM_CALL NetDll_closesocket_shim(PPCContext* ppc_context,
KernelState* kernel_state) {
uint32_t arg0 = SHIM_GET_ARG_32(0);
uint32_t caller = SHIM_GET_ARG_32(0);
uint32_t socket_handle = SHIM_GET_ARG_32(1);
XELOGD("NetDll_closesocket(%d, %.8X)", arg0, socket_handle);
XELOGD("NetDll_closesocket(%d, %.8X)", caller, socket_handle);
int ret = closesocket(socket_handle);
SHIM_SET_RETURN_32(ret);
@ -287,14 +318,14 @@ SHIM_CALL NetDll_closesocket_shim(PPCContext* ppc_context,
SHIM_CALL NetDll_setsockopt_shim(PPCContext* ppc_context,
KernelState* kernel_state) {
uint32_t arg0 = SHIM_GET_ARG_32(0);
uint32_t caller = SHIM_GET_ARG_32(0);
uint32_t socket_handle = SHIM_GET_ARG_32(1);
uint32_t level = SHIM_GET_ARG_32(2);
uint32_t optname = SHIM_GET_ARG_32(3);
uint32_t optval_ptr = SHIM_GET_ARG_32(4);
uint32_t optlen = SHIM_GET_ARG_32(5);
XELOGD("NetDll_setsockopt(%d, %.8X, %d, %d, %.8X, %d)", arg0, socket_handle,
XELOGD("NetDll_setsockopt(%d, %.8X, %d, %d, %.8X, %d)", caller, socket_handle,
level, optname, optval_ptr, optlen);
char* optval = reinterpret_cast<char*>(SHIM_MEM_ADDR(optval_ptr));
@ -305,12 +336,12 @@ SHIM_CALL NetDll_setsockopt_shim(PPCContext* ppc_context,
SHIM_CALL NetDll_ioctlsocket_shim(PPCContext* ppc_context,
KernelState* kernel_state) {
uint32_t arg0 = SHIM_GET_ARG_32(0);
uint32_t caller = SHIM_GET_ARG_32(0);
uint32_t socket_handle = SHIM_GET_ARG_32(1);
uint32_t cmd = SHIM_GET_ARG_32(2);
uint32_t arg_ptr = SHIM_GET_ARG_32(3);
XELOGD("NetDll_ioctlsocket(%d, %.8X, %.8X, %.8X)", arg0, socket_handle, cmd,
XELOGD("NetDll_ioctlsocket(%d, %.8X, %.8X, %.8X)", caller, socket_handle, cmd,
arg_ptr);
u_long arg = SHIM_MEM_32(arg_ptr);
@ -321,12 +352,12 @@ SHIM_CALL NetDll_ioctlsocket_shim(PPCContext* ppc_context,
}
SHIM_CALL NetDll_bind_shim(PPCContext* ppc_context, KernelState* kernel_state) {
uint32_t arg0 = SHIM_GET_ARG_32(0);
uint32_t caller = SHIM_GET_ARG_32(0);
uint32_t socket_handle = SHIM_GET_ARG_32(1);
uint32_t name_ptr = SHIM_GET_ARG_32(2);
uint32_t namelen = SHIM_GET_ARG_32(3);
XELOGD("NetDll_bind(%d, %.8X, %.8X, %d)", arg0, socket_handle, name_ptr,
XELOGD("NetDll_bind(%d, %.8X, %.8X, %d)", caller, socket_handle, name_ptr,
namelen);
sockaddr name;
@ -338,12 +369,12 @@ SHIM_CALL NetDll_bind_shim(PPCContext* ppc_context, KernelState* kernel_state) {
SHIM_CALL NetDll_connect_shim(PPCContext* ppc_context,
KernelState* kernel_state) {
uint32_t arg0 = SHIM_GET_ARG_32(0);
uint32_t caller = SHIM_GET_ARG_32(0);
uint32_t socket_handle = SHIM_GET_ARG_32(1);
uint32_t name_ptr = SHIM_GET_ARG_32(2);
uint32_t namelen = SHIM_GET_ARG_32(3);
XELOGD("NetDll_connect(%d, %.8X, %.8X, %d)", arg0, socket_handle, name_ptr,
XELOGD("NetDll_connect(%d, %.8X, %.8X, %d)", caller, socket_handle, name_ptr,
namelen);
sockaddr name;
@ -355,11 +386,11 @@ SHIM_CALL NetDll_connect_shim(PPCContext* ppc_context,
SHIM_CALL NetDll_listen_shim(PPCContext* ppc_context,
KernelState* kernel_state) {
uint32_t arg0 = SHIM_GET_ARG_32(0);
uint32_t caller = SHIM_GET_ARG_32(0);
uint32_t socket_handle = SHIM_GET_ARG_32(1);
int32_t backlog = SHIM_GET_ARG_32(2);
XELOGD("NetDll_listen(%d, %.8X, %d)", arg0, socket_handle, backlog);
XELOGD("NetDll_listen(%d, %.8X, %d)", caller, socket_handle, backlog);
int ret = listen(socket_handle, backlog);
@ -368,12 +399,12 @@ SHIM_CALL NetDll_listen_shim(PPCContext* ppc_context,
SHIM_CALL NetDll_accept_shim(PPCContext* ppc_context,
KernelState* kernel_state) {
uint32_t arg0 = SHIM_GET_ARG_32(0);
uint32_t caller = SHIM_GET_ARG_32(0);
uint32_t socket_handle = SHIM_GET_ARG_32(1);
uint32_t addr_ptr = SHIM_GET_ARG_32(2);
uint32_t addrlen_ptr = SHIM_GET_ARG_32(3);
XELOGD("NetDll_accept(%d, %.8X, %d)", arg0, socket_handle, addr_ptr,
XELOGD("NetDll_accept(%d, %.8X, %d)", caller, socket_handle, addr_ptr,
addrlen_ptr);
sockaddr addr;
@ -413,14 +444,14 @@ void StoreFdset(const fd_set& src, uint8_t* dest) {
SHIM_CALL NetDll_select_shim(PPCContext* ppc_context,
KernelState* kernel_state) {
uint32_t arg0 = SHIM_GET_ARG_32(0);
uint32_t caller = SHIM_GET_ARG_32(0);
uint32_t nfds = SHIM_GET_ARG_32(1);
uint32_t readfds_ptr = SHIM_GET_ARG_32(2);
uint32_t writefds_ptr = SHIM_GET_ARG_32(3);
uint32_t exceptfds_ptr = SHIM_GET_ARG_32(4);
uint32_t timeout_ptr = SHIM_GET_ARG_32(5);
XELOGD("NetDll_select(%d, %d, %.8X, %.8X, %.8X, %.8X)", arg0, nfds,
XELOGD("NetDll_select(%d, %d, %.8X, %.8X, %.8X, %.8X)", caller, nfds,
readfds_ptr, writefds_ptr, exceptfds_ptr, timeout_ptr);
fd_set readfds = {0};
@ -460,13 +491,13 @@ SHIM_CALL NetDll_select_shim(PPCContext* ppc_context,
}
SHIM_CALL NetDll_recv_shim(PPCContext* ppc_context, KernelState* kernel_state) {
uint32_t arg0 = SHIM_GET_ARG_32(0);
uint32_t caller = SHIM_GET_ARG_32(0);
uint32_t socket_handle = SHIM_GET_ARG_32(1);
uint32_t buf_ptr = SHIM_GET_ARG_32(2);
uint32_t len = SHIM_GET_ARG_32(3);
uint32_t flags = SHIM_GET_ARG_32(4);
XELOGD("NetDll_recv(%d, %.8X, %.8X, %d, %d)", arg0, socket_handle, buf_ptr,
XELOGD("NetDll_recv(%d, %.8X, %.8X, %d, %d)", caller, socket_handle, buf_ptr,
len, flags);
int ret = recv(socket_handle, reinterpret_cast<char*>(SHIM_MEM_ADDR(buf_ptr)),
@ -477,7 +508,7 @@ SHIM_CALL NetDll_recv_shim(PPCContext* ppc_context, KernelState* kernel_state) {
SHIM_CALL NetDll_recvfrom_shim(PPCContext* ppc_context,
KernelState* kernel_state) {
uint32_t arg0 = SHIM_GET_ARG_32(0);
uint32_t caller = SHIM_GET_ARG_32(0);
uint32_t socket_handle = SHIM_GET_ARG_32(1);
uint32_t buf_ptr = SHIM_GET_ARG_32(2);
uint32_t len = SHIM_GET_ARG_32(3);
@ -485,7 +516,7 @@ SHIM_CALL NetDll_recvfrom_shim(PPCContext* ppc_context,
uint32_t from_ptr = SHIM_GET_ARG_32(5);
uint32_t fromlen_ptr = SHIM_GET_ARG_32(6);
XELOGD("NetDll_recvfrom(%d, %.8X, %.8X, %d, %d, %.8X, %.8X)", arg0,
XELOGD("NetDll_recvfrom(%d, %.8X, %.8X, %d, %d, %.8X, %.8X)", caller,
socket_handle, buf_ptr, len, flags, from_ptr, fromlen_ptr);
sockaddr from;
@ -505,13 +536,13 @@ SHIM_CALL NetDll_recvfrom_shim(PPCContext* ppc_context,
}
SHIM_CALL NetDll_send_shim(PPCContext* ppc_context, KernelState* kernel_state) {
uint32_t arg0 = SHIM_GET_ARG_32(0);
uint32_t caller = SHIM_GET_ARG_32(0);
uint32_t socket_handle = SHIM_GET_ARG_32(1);
uint32_t buf_ptr = SHIM_GET_ARG_32(2);
uint32_t len = SHIM_GET_ARG_32(3);
uint32_t flags = SHIM_GET_ARG_32(4);
XELOGD("NetDll_send(%d, %.8X, %.8X, %d, %d)", arg0, socket_handle, buf_ptr,
XELOGD("NetDll_send(%d, %.8X, %.8X, %d, %d)", caller, socket_handle, buf_ptr,
len, flags);
int ret = send(socket_handle, reinterpret_cast<char*>(SHIM_MEM_ADDR(buf_ptr)),
@ -522,7 +553,7 @@ SHIM_CALL NetDll_send_shim(PPCContext* ppc_context, KernelState* kernel_state) {
SHIM_CALL NetDll_sendto_shim(PPCContext* ppc_context,
KernelState* kernel_state) {
uint32_t arg0 = SHIM_GET_ARG_32(0);
uint32_t caller = SHIM_GET_ARG_32(0);
uint32_t socket_handle = SHIM_GET_ARG_32(1);
uint32_t buf_ptr = SHIM_GET_ARG_32(2);
uint32_t len = SHIM_GET_ARG_32(3);
@ -530,7 +561,7 @@ SHIM_CALL NetDll_sendto_shim(PPCContext* ppc_context,
uint32_t to_ptr = SHIM_GET_ARG_32(5);
uint32_t tolen = SHIM_GET_ARG_32(6);
XELOGD("NetDll_sendto(%d, %.8X, %.8X, %d, %d, %.8X, %d)", arg0, socket_handle,
XELOGD("NetDll_sendto(%d, %.8X, %.8X, %d, %d, %.8X, %d)", caller, socket_handle,
buf_ptr, len, flags, to_ptr, tolen);
sockaddr to;
@ -553,7 +584,6 @@ void xe::kernel::xam::RegisterNetExports(
SHIM_SET_MAPPING("xam.xex", NetDll_WSAStartup, state);
SHIM_SET_MAPPING("xam.xex", NetDll_WSACleanup, state);
SHIM_SET_MAPPING("xam.xex", NetDll_WSAGetLastError, state);
SHIM_SET_MAPPING("xam.xex", NetDll_XNetGetTitleXnAddr, state);
SHIM_SET_MAPPING("xam.xex", NetDll_XNetGetEthernetLinkStatus, state);
SHIM_SET_MAPPING("xam.xex", NetDll_XNetQosServiceLookup, state);
SHIM_SET_MAPPING("xam.xex", NetDll_inet_addr, state);