472 lines
15 KiB
C++
472 lines
15 KiB
C++
/**
|
|
******************************************************************************
|
|
* Xenia : Xbox 360 Emulator Research Project *
|
|
******************************************************************************
|
|
* Copyright 2013 Ben Vanik. All rights reserved. *
|
|
* Released under the BSD license - see LICENSE in the root for more details. *
|
|
******************************************************************************
|
|
*/
|
|
|
|
#include "xenia/base/logging.h"
|
|
#include "xenia/kernel/kernel_state.h"
|
|
#include "xenia/kernel/objects/xenumerator.h"
|
|
#include "xenia/kernel/objects/xthread.h"
|
|
#include "xenia/kernel/util/shim_utils.h"
|
|
#include "xenia/kernel/xam_private.h"
|
|
#include "xenia/xbox.h"
|
|
|
|
namespace xe {
|
|
namespace kernel {
|
|
|
|
SHIM_CALL XamUserGetXUID_shim(PPCContext* ppc_state, KernelState* state) {
|
|
uint32_t user_index = SHIM_GET_ARG_32(0);
|
|
uint32_t unk = SHIM_GET_ARG_32(1);
|
|
uint32_t xuid_ptr = SHIM_GET_ARG_32(2);
|
|
|
|
XELOGD("XamUserGetXUID(%d, %.8X, %.8X)", user_index, unk, xuid_ptr);
|
|
|
|
if (user_index == 0) {
|
|
const auto& user_profile = state->user_profile();
|
|
if (xuid_ptr) {
|
|
SHIM_SET_MEM_64(xuid_ptr, user_profile->xuid());
|
|
}
|
|
SHIM_SET_RETURN_32(0);
|
|
} else {
|
|
SHIM_SET_RETURN_32(X_ERROR_NO_SUCH_USER);
|
|
}
|
|
}
|
|
|
|
SHIM_CALL XamUserGetSigninState_shim(PPCContext* ppc_state,
|
|
KernelState* state) {
|
|
uint32_t user_index = SHIM_GET_ARG_32(0);
|
|
|
|
XELOGD("XamUserGetSigninState(%d)", user_index);
|
|
|
|
// Lie and say we are signed in, but local-only.
|
|
// This should keep games from asking us to sign in and also keep them
|
|
// from initializing the network.
|
|
if (user_index == 0 || (user_index & 0xFF) == 0xFF) {
|
|
const auto& user_profile = state->user_profile();
|
|
auto signin_state = user_profile->signin_state();
|
|
SHIM_SET_RETURN_64(signin_state);
|
|
} else {
|
|
SHIM_SET_RETURN_64(0);
|
|
}
|
|
}
|
|
|
|
SHIM_CALL XamUserGetSigninInfo_shim(PPCContext* ppc_state, KernelState* state) {
|
|
uint32_t user_index = SHIM_GET_ARG_32(0);
|
|
uint32_t flags = SHIM_GET_ARG_32(1);
|
|
uint32_t info_ptr = SHIM_GET_ARG_32(2);
|
|
|
|
XELOGD("XamUserGetSigninInfo(%d, %.8X, %.8X)", user_index, flags, info_ptr);
|
|
|
|
if (user_index == 0) {
|
|
const auto& user_profile = state->user_profile();
|
|
SHIM_SET_MEM_64(info_ptr + 0, user_profile->xuid());
|
|
SHIM_SET_MEM_32(info_ptr + 8, 0); // maybe zero?
|
|
SHIM_SET_MEM_32(info_ptr + 12, user_profile->signin_state());
|
|
SHIM_SET_MEM_32(info_ptr + 16, 0); // ?
|
|
SHIM_SET_MEM_32(info_ptr + 20, 0); // ?
|
|
char* buffer = (char*)SHIM_MEM_ADDR(info_ptr + 24);
|
|
strcpy(buffer, user_profile->name().data());
|
|
SHIM_SET_RETURN_32(0);
|
|
} else {
|
|
SHIM_SET_RETURN_32(X_ERROR_NO_SUCH_USER);
|
|
}
|
|
}
|
|
|
|
SHIM_CALL XamUserGetName_shim(PPCContext* ppc_state, KernelState* state) {
|
|
uint32_t user_index = SHIM_GET_ARG_32(0);
|
|
uint32_t buffer_ptr = SHIM_GET_ARG_32(1);
|
|
uint32_t buffer_len = SHIM_GET_ARG_32(2);
|
|
|
|
XELOGD("XamUserGetName(%d, %.8X, %d)", user_index, buffer_ptr, buffer_len);
|
|
|
|
if (user_index == 0) {
|
|
const auto& user_profile = state->user_profile();
|
|
char* buffer = (char*)SHIM_MEM_ADDR(buffer_ptr);
|
|
strcpy(buffer, user_profile->name().data());
|
|
SHIM_SET_RETURN_32(0);
|
|
} else {
|
|
SHIM_SET_RETURN_32(X_ERROR_NO_SUCH_USER);
|
|
}
|
|
}
|
|
|
|
// http://freestyledash.googlecode.com/svn/trunk/Freestyle/Tools/Generic/xboxtools.cpp
|
|
SHIM_CALL XamUserReadProfileSettings_shim(PPCContext* ppc_state,
|
|
KernelState* state) {
|
|
uint32_t title_id = SHIM_GET_ARG_32(0);
|
|
uint32_t user_index = SHIM_GET_ARG_32(1);
|
|
uint32_t unk_0 = SHIM_GET_ARG_32(2);
|
|
uint32_t unk_1 = SHIM_GET_ARG_32(3);
|
|
uint32_t setting_count = SHIM_GET_ARG_32(4);
|
|
uint32_t setting_ids_ptr = SHIM_GET_ARG_32(5);
|
|
uint32_t buffer_size_ptr = SHIM_GET_ARG_32(6);
|
|
uint32_t buffer_ptr = SHIM_GET_ARG_32(7);
|
|
// arg8 is in stack!
|
|
uint32_t sp = (uint32_t)ppc_state->r[1];
|
|
uint32_t overlapped_ptr = SHIM_MEM_32(sp + 0x54);
|
|
|
|
uint32_t buffer_size = SHIM_MEM_32(buffer_size_ptr);
|
|
|
|
XELOGD(
|
|
"XamUserReadProfileSettings(%.8X, %d, %d, %d, %d, %.8X, %.8X(%d), %.8X, "
|
|
"%.8X)",
|
|
title_id, user_index, unk_0, unk_1, setting_count, setting_ids_ptr,
|
|
buffer_size_ptr, buffer_size, buffer_ptr, overlapped_ptr);
|
|
|
|
// Title ID = 0 means us.
|
|
// 0xfffe07d1 = profile?
|
|
|
|
if (user_index == 255) {
|
|
user_index = 0;
|
|
}
|
|
|
|
if (user_index) {
|
|
// Only support user 0.
|
|
if (overlapped_ptr) {
|
|
state->CompleteOverlappedImmediate(overlapped_ptr, X_ERROR_NOT_FOUND);
|
|
SHIM_SET_RETURN_32(X_ERROR_IO_PENDING);
|
|
} else {
|
|
SHIM_SET_RETURN_32(X_ERROR_NOT_FOUND);
|
|
}
|
|
return;
|
|
}
|
|
const auto& user_profile = state->user_profile();
|
|
|
|
// First call asks for size (fill buffer_size_ptr).
|
|
// Second call asks for buffer contents with that size.
|
|
|
|
// http://cs.rin.ru/forum/viewtopic.php?f=38&t=60668&hilit=gfwl+live&start=195
|
|
// Result buffer is:
|
|
// uint32_t setting_count
|
|
// struct {
|
|
// uint32_t source;
|
|
// (4b pad)
|
|
// uint32_t user_index;
|
|
// (4b pad)
|
|
// uint32_t setting_id;
|
|
// (4b pad)
|
|
// <data>
|
|
// } settings[setting_count]
|
|
const size_t kSettingSize = 4 + 4 + 4 + 4 + 4 + 4 + 16;
|
|
|
|
// Compute required size.
|
|
bool any_missing = false;
|
|
uint32_t size_needed = 4 + 4 + setting_count * kSettingSize;
|
|
for (uint32_t n = 0; n < setting_count; ++n) {
|
|
uint32_t setting_id = SHIM_MEM_32(setting_ids_ptr + n * 4);
|
|
auto setting = user_profile->GetSetting(setting_id);
|
|
if (setting) {
|
|
auto extra_size = static_cast<uint32_t>(setting->extra_size());
|
|
size_needed += extra_size;
|
|
} else {
|
|
any_missing = true;
|
|
XELOGE("XamUserReadProfileSettings requested unimplemented setting %.8X",
|
|
setting_id);
|
|
}
|
|
}
|
|
if (any_missing) {
|
|
// TODO(benvanik): don't fail? most games don't even check!
|
|
if (overlapped_ptr) {
|
|
state->CompleteOverlappedImmediate(overlapped_ptr,
|
|
X_ERROR_INVALID_PARAMETER);
|
|
SHIM_SET_RETURN_32(X_ERROR_IO_PENDING);
|
|
} else {
|
|
SHIM_SET_RETURN_32(X_ERROR_INVALID_PARAMETER);
|
|
}
|
|
return;
|
|
}
|
|
SHIM_SET_MEM_32(buffer_size_ptr, size_needed);
|
|
if (!buffer_ptr || buffer_size < size_needed) {
|
|
if (overlapped_ptr) {
|
|
state->CompleteOverlappedImmediate(overlapped_ptr,
|
|
X_ERROR_INSUFFICIENT_BUFFER);
|
|
SHIM_SET_RETURN_32(X_ERROR_IO_PENDING);
|
|
} else {
|
|
SHIM_SET_RETURN_32(X_ERROR_INSUFFICIENT_BUFFER);
|
|
}
|
|
return;
|
|
}
|
|
|
|
SHIM_SET_MEM_32(buffer_ptr + 0, setting_count);
|
|
SHIM_SET_MEM_32(buffer_ptr + 4, buffer_ptr + 8);
|
|
|
|
size_t buffer_offset = 4 + setting_count * kSettingSize;
|
|
size_t user_data_ptr = buffer_ptr + 8;
|
|
for (uint32_t n = 0; n < setting_count; ++n) {
|
|
uint32_t setting_id = SHIM_MEM_32(setting_ids_ptr + n * 4);
|
|
auto setting = user_profile->GetSetting(setting_id);
|
|
if (setting) {
|
|
SHIM_SET_MEM_32(user_data_ptr + 0, setting->is_title_specific() ? 2 : 1);
|
|
} else {
|
|
SHIM_SET_MEM_32(user_data_ptr + 0, 0);
|
|
}
|
|
SHIM_SET_MEM_32(user_data_ptr + 8, user_index);
|
|
SHIM_SET_MEM_32(user_data_ptr + 16, setting_id);
|
|
if (setting) {
|
|
buffer_offset = setting->Append(SHIM_MEM_ADDR(user_data_ptr + 24),
|
|
SHIM_MEM_ADDR(buffer_ptr), buffer_offset);
|
|
} else {
|
|
memset(SHIM_MEM_ADDR(user_data_ptr + 24), 0, 16);
|
|
}
|
|
user_data_ptr += kSettingSize;
|
|
}
|
|
|
|
if (overlapped_ptr) {
|
|
state->CompleteOverlappedImmediate(overlapped_ptr, X_ERROR_SUCCESS);
|
|
SHIM_SET_RETURN_32(X_ERROR_IO_PENDING);
|
|
} else {
|
|
SHIM_SET_RETURN_32(X_ERROR_SUCCESS);
|
|
}
|
|
}
|
|
|
|
SHIM_CALL XamUserWriteProfileSettings_shim(PPCContext* ppc_state,
|
|
KernelState* state) {
|
|
uint32_t user_index = SHIM_GET_ARG_32(0);
|
|
uint32_t unknown = SHIM_GET_ARG_32(1);
|
|
uint32_t setting_count = SHIM_GET_ARG_32(2);
|
|
uint32_t settings_ptr = SHIM_GET_ARG_32(3);
|
|
uint32_t overlapped_ptr = SHIM_GET_ARG_32(4);
|
|
|
|
XELOGD(
|
|
"XamUserWriteProfileSettings(%.8X, %d, %d, %d, %d, %.8X, %.8X(%d), %.8X, "
|
|
"%.8X)",
|
|
user_index, unknown, setting_count, settings_ptr, overlapped_ptr);
|
|
|
|
if (!setting_count || !settings_ptr) {
|
|
if (overlapped_ptr) {
|
|
state->CompleteOverlappedImmediate(overlapped_ptr,
|
|
X_ERROR_INVALID_PARAMETER);
|
|
SHIM_SET_RETURN_32(X_ERROR_IO_PENDING);
|
|
} else {
|
|
SHIM_SET_RETURN_32(X_ERROR_INVALID_PARAMETER);
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (user_index == 255) {
|
|
user_index = 0;
|
|
}
|
|
|
|
if (user_index) {
|
|
// Only support user 0.
|
|
SHIM_SET_RETURN_32(X_ERROR_NOT_FOUND);
|
|
return;
|
|
}
|
|
|
|
const auto& user_profile = state->user_profile();
|
|
|
|
// TODO: Update and save settings.
|
|
|
|
if (overlapped_ptr) {
|
|
state->CompleteOverlappedImmediate(overlapped_ptr, X_ERROR_SUCCESS);
|
|
SHIM_SET_RETURN_32(X_ERROR_IO_PENDING);
|
|
} else {
|
|
SHIM_SET_RETURN_32(X_ERROR_SUCCESS);
|
|
}
|
|
}
|
|
|
|
SHIM_CALL XamUserCheckPrivilege_shim(PPCContext* ppc_state,
|
|
KernelState* state) {
|
|
uint32_t user_index = SHIM_GET_ARG_32(0);
|
|
uint32_t mask = SHIM_GET_ARG_32(1);
|
|
uint32_t out_value_ptr = SHIM_GET_ARG_32(2);
|
|
|
|
XELOGD("XamUserCheckPrivilege(%d, %.8X, %.8X)", user_index, mask,
|
|
out_value_ptr);
|
|
|
|
// If we deny everything, games should hopefully not try to do stuff.
|
|
SHIM_SET_MEM_32(out_value_ptr, 0);
|
|
|
|
SHIM_SET_RETURN_32(X_ERROR_SUCCESS);
|
|
}
|
|
|
|
SHIM_CALL XamUserAreUsersFriends_shim(PPCContext* ppc_state,
|
|
KernelState* state) {
|
|
uint32_t user_index = SHIM_GET_ARG_32(0);
|
|
uint32_t unk1 = SHIM_GET_ARG_32(1);
|
|
uint32_t unk2 = SHIM_GET_ARG_32(2);
|
|
uint32_t out_value_ptr = SHIM_GET_ARG_32(3);
|
|
uint32_t overlapped_ptr = SHIM_GET_ARG_32(4);
|
|
|
|
XELOGD("XamUserAreUsersFriends(%d, %.8X, %.8X, %.8X, %.8X)", user_index, unk1,
|
|
unk2, out_value_ptr, overlapped_ptr);
|
|
|
|
if (user_index == 255) {
|
|
user_index = 0;
|
|
}
|
|
|
|
SHIM_SET_MEM_32(out_value_ptr, 0);
|
|
|
|
if (user_index) {
|
|
// Only support user 0.
|
|
SHIM_SET_RETURN_32(X_ERROR_NOT_LOGGED_ON);
|
|
return;
|
|
}
|
|
|
|
X_RESULT result = X_ERROR_SUCCESS;
|
|
|
|
const auto& user_profile = state->user_profile();
|
|
if (user_profile->signin_state() == 0) {
|
|
result = X_ERROR_NOT_LOGGED_ON;
|
|
}
|
|
|
|
// No friends!
|
|
SHIM_SET_MEM_32(out_value_ptr, 0);
|
|
|
|
if (overlapped_ptr) {
|
|
state->CompleteOverlappedImmediate(overlapped_ptr, result);
|
|
SHIM_SET_RETURN_32(X_ERROR_IO_PENDING);
|
|
} else {
|
|
SHIM_SET_RETURN_32(result);
|
|
}
|
|
}
|
|
|
|
SHIM_CALL XamShowSigninUI_shim(PPCContext* ppc_state, KernelState* state) {
|
|
uint32_t unk_0 = SHIM_GET_ARG_32(0);
|
|
uint32_t unk_mask = SHIM_GET_ARG_32(1);
|
|
|
|
XELOGD("XamShowSigninUI(%d, %.8X)", unk_0, unk_mask);
|
|
|
|
// Mask values vary. Probably matching user types? Local/remote?
|
|
// Games seem to sit and loop until we trigger this notification.
|
|
state->BroadcastNotification(0x00000009, 0);
|
|
|
|
SHIM_SET_RETURN_32(X_ERROR_SUCCESS);
|
|
}
|
|
|
|
SHIM_CALL XamUserCreateAchievementEnumerator_shim(PPCContext* ppc_state,
|
|
KernelState* state) {
|
|
uint32_t title_id = SHIM_GET_ARG_32(0);
|
|
uint32_t user_index = SHIM_GET_ARG_32(1);
|
|
uint32_t xuid = SHIM_GET_ARG_32(2);
|
|
uint32_t flags = SHIM_GET_ARG_32(3);
|
|
uint32_t offset = SHIM_GET_ARG_32(4);
|
|
uint32_t count = SHIM_GET_ARG_32(5);
|
|
uint32_t buffer_size_ptr = SHIM_GET_ARG_32(6);
|
|
uint32_t handle_ptr = SHIM_GET_ARG_32(7);
|
|
|
|
XELOGD(
|
|
"XamUserCreateAchievementEnumerator(%.8X, %d, %.8X, %.8X, %d, %d, %.8X, "
|
|
"%.8X)",
|
|
title_id, user_index, xuid, flags, offset, count, buffer_size_ptr,
|
|
handle_ptr);
|
|
|
|
if (buffer_size_ptr) {
|
|
// TODO(benvanik): struct size/etc.
|
|
SHIM_SET_MEM_32(buffer_size_ptr, 64 * count);
|
|
}
|
|
|
|
auto e = new XStaticEnumerator(state, count, 64);
|
|
e->Initialize();
|
|
|
|
SHIM_SET_MEM_32(handle_ptr, e->handle());
|
|
|
|
SHIM_SET_RETURN_32(X_ERROR_SUCCESS);
|
|
}
|
|
|
|
SHIM_CALL XamParseGamerTileKey_shim(PPCContext* ppc_state, KernelState* state) {
|
|
uint32_t key_ptr = SHIM_GET_ARG_32(0);
|
|
uint32_t out0_ptr = SHIM_GET_ARG_32(1);
|
|
uint32_t out1_ptr = SHIM_GET_ARG_32(2);
|
|
uint32_t out2_ptr = SHIM_GET_ARG_32(3);
|
|
|
|
XELOGD("XamParseGamerTileKey(%.8X, %.8X, %.8X, %.8X, %.8X, %.8X)", key_ptr,
|
|
out0_ptr, out1_ptr, out2_ptr);
|
|
|
|
SHIM_SET_MEM_32(out0_ptr, 0xC0DE0001);
|
|
SHIM_SET_MEM_32(out1_ptr, 0xC0DE0002);
|
|
SHIM_SET_MEM_32(out2_ptr, 0xC0DE0003);
|
|
|
|
SHIM_SET_RETURN_32(X_ERROR_SUCCESS);
|
|
}
|
|
|
|
SHIM_CALL XamReadTileToTexture_shim(PPCContext* ppc_state, KernelState* state) {
|
|
uint32_t unk0 = SHIM_GET_ARG_32(0); // const?
|
|
uint32_t unk1 = SHIM_GET_ARG_32(1); // out0 from XamParseGamerTileKey
|
|
uint32_t unk2 = SHIM_GET_ARG_32(2); // some variant of out1/out2
|
|
uint32_t unk3 = SHIM_GET_ARG_32(3); // const?
|
|
uint32_t buffer_ptr = SHIM_GET_ARG_32(4);
|
|
uint32_t stride = SHIM_GET_ARG_32(5);
|
|
uint32_t height = SHIM_GET_ARG_32(6);
|
|
uint32_t overlapped_ptr = SHIM_GET_ARG_32(7);
|
|
|
|
XELOGD("XamReadTileToTexture(%.8X, %.8X, %.8X, %.8X, %.8X, %.8X)", unk0, unk1,
|
|
unk2, unk3, buffer_ptr, stride, height, overlapped_ptr);
|
|
|
|
if (overlapped_ptr) {
|
|
state->CompleteOverlappedImmediate(overlapped_ptr, X_ERROR_SUCCESS);
|
|
SHIM_SET_RETURN_32(X_ERROR_IO_PENDING);
|
|
} else {
|
|
SHIM_SET_RETURN_32(X_ERROR_SUCCESS);
|
|
}
|
|
}
|
|
|
|
SHIM_CALL XamWriteGamerTile_shim(PPCContext* ppc_state, KernelState* state) {
|
|
uint32_t arg0 = SHIM_GET_ARG_32(0);
|
|
uint32_t arg1 = SHIM_GET_ARG_32(1);
|
|
uint32_t arg2 = SHIM_GET_ARG_32(2);
|
|
uint32_t arg3 = SHIM_GET_ARG_32(3);
|
|
uint32_t arg4 = SHIM_GET_ARG_32(4);
|
|
uint32_t overlapped_ptr = SHIM_GET_ARG_32(5);
|
|
|
|
XELOGD("XamWriteGamerTile(%.8X, %.8X, %.8X, %.8X, %.8X, %.8X)", arg0, arg1,
|
|
arg2, arg3, arg4, overlapped_ptr);
|
|
|
|
if (overlapped_ptr) {
|
|
state->CompleteOverlappedImmediate(overlapped_ptr, X_ERROR_SUCCESS);
|
|
SHIM_SET_RETURN_32(X_ERROR_IO_PENDING);
|
|
} else {
|
|
SHIM_SET_RETURN_32(X_ERROR_SUCCESS);
|
|
}
|
|
}
|
|
|
|
SHIM_CALL XamSessionCreateHandle_shim(PPCContext* ppc_state,
|
|
KernelState* state) {
|
|
uint32_t handle_ptr = SHIM_GET_ARG_32(0);
|
|
|
|
XELOGD("XamSessionCreateHandle(%.8X)", handle_ptr);
|
|
|
|
SHIM_SET_MEM_32(handle_ptr, 0xCAFEDEAD);
|
|
|
|
SHIM_SET_RETURN_32(X_ERROR_SUCCESS);
|
|
}
|
|
|
|
SHIM_CALL XamSessionRefObjByHandle_shim(PPCContext* ppc_state,
|
|
KernelState* state) {
|
|
uint32_t handle = SHIM_GET_ARG_32(0);
|
|
uint32_t obj_ptr = SHIM_GET_ARG_32(1);
|
|
|
|
XELOGD("XamSessionRefObjByHandle(%.8X, %.8X)", handle, obj_ptr);
|
|
|
|
assert_true(handle == 0xCAFEDEAD);
|
|
|
|
SHIM_SET_MEM_32(obj_ptr, 0);
|
|
|
|
SHIM_SET_RETURN_32(X_ERROR_FUNCTION_FAILED);
|
|
}
|
|
|
|
} // namespace kernel
|
|
} // namespace xe
|
|
|
|
void xe::kernel::xam::RegisterUserExports(
|
|
xe::cpu::ExportResolver* export_resolver, KernelState* state) {
|
|
SHIM_SET_MAPPING("xam.xex", XamUserGetXUID, state);
|
|
SHIM_SET_MAPPING("xam.xex", XamUserGetSigninState, state);
|
|
SHIM_SET_MAPPING("xam.xex", XamUserGetSigninInfo, state);
|
|
SHIM_SET_MAPPING("xam.xex", XamUserGetName, state);
|
|
SHIM_SET_MAPPING("xam.xex", XamUserReadProfileSettings, state);
|
|
SHIM_SET_MAPPING("xam.xex", XamUserWriteProfileSettings, state);
|
|
SHIM_SET_MAPPING("xam.xex", XamUserCheckPrivilege, state);
|
|
SHIM_SET_MAPPING("xam.xex", XamUserAreUsersFriends, state);
|
|
SHIM_SET_MAPPING("xam.xex", XamShowSigninUI, state);
|
|
SHIM_SET_MAPPING("xam.xex", XamUserCreateAchievementEnumerator, state);
|
|
SHIM_SET_MAPPING("xam.xex", XamParseGamerTileKey, state);
|
|
SHIM_SET_MAPPING("xam.xex", XamReadTileToTexture, state);
|
|
SHIM_SET_MAPPING("xam.xex", XamWriteGamerTile, state);
|
|
SHIM_SET_MAPPING("xam.xex", XamSessionCreateHandle, state);
|
|
SHIM_SET_MAPPING("xam.xex", XamSessionRefObjByHandle, state);
|
|
}
|