359 lines
11 KiB
C++
359 lines
11 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/common.h>
|
|
#include <xenia/core.h>
|
|
#include <xenia/xbox.h>
|
|
#include <xenia/kernel/kernel_state.h>
|
|
#include <xenia/kernel/xam_private.h>
|
|
#include <xenia/kernel/objects/xenumerator.h>
|
|
#include <xenia/kernel/objects/xthread.h>
|
|
#include <xenia/kernel/util/shim_utils.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();
|
|
SHIM_SET_RETURN_64(user_profile->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.
|
|
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.
|
|
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;
|
|
}
|
|
}
|
|
SHIM_SET_MEM_32(buffer_size_ptr, size_needed);
|
|
if (buffer_size < size_needed) {
|
|
if (overlapped_ptr) {
|
|
state->CompleteOverlappedImmediate(overlapped_ptr, X_ERROR_INSUFFICIENT_BUFFER);
|
|
}
|
|
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) {
|
|
SHIM_SET_RETURN_32(X_ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
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 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 = 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, handle_ptr);
|
|
|
|
XEnumerator* e = new XEnumerator(state);
|
|
e->Initialize();
|
|
|
|
SHIM_SET_MEM_32(handle_ptr, e->handle());
|
|
|
|
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);
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace kernel
|
|
} // namespace xe
|
|
|
|
|
|
void xe::kernel::xam::RegisterUserExports(
|
|
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", XamShowSigninUI, state);
|
|
SHIM_SET_MAPPING("xam.xex", XamUserCreateAchievementEnumerator, state);
|
|
SHIM_SET_MAPPING("xam.xex", XamWriteGamerTile, state);
|
|
}
|