mirror of
https://github.com/cemu-project/Cemu.git
synced 2025-07-02 21:11:17 +12:00
caa57a3cfd
* script changes - no arguments * script changes with 2 arguments * script changes with > 2 arguments * script conversions with 1 argument - pt. 1 * script conversions with 1 argument - pt. 2 * script conversions with 1 argument - pt. 3 * script conversions with 1 argument - pt. 4 * script conversions with 1 argument - pt. 5 Pointer format hunting * Fixed pointer format * script conversions with 1 argument - final * fixed conversion in non utf-8 file * fixed conversion with capital letter * actually fixed conversion with capital letter * fixed another capital lettering issue * Added conversions with LR removed * removed LR from logs * Converted logs that previously contained LR * converted log that originally specified string length * fixed log with commas in main text * fixed multi-line log * Fixed more logs with commas in main text * Fixed unformatted pointer * added conversion with float value * converted lines with double parameters * converted missed line * corrected argument formatting Co-authored-by: Crementif <26669564+Crementif@users.noreply.github.com> * Fixed misspellings of "unhandled" unhandeled -> unhandled Co-authored-by: Crementif <26669564+Crementif@users.noreply.github.com> --------- Co-authored-by: Crementif <26669564+Crementif@users.noreply.github.com>
1804 lines
55 KiB
C++
1804 lines
55 KiB
C++
#include "Cafe/OS/common/OSCommon.h"
|
|
#include "Cafe/OS/libs/nn_common.h"
|
|
#include "Cafe/OS/libs/nn_act/nn_act.h"
|
|
#include "Cafe/OS/libs/coreinit/coreinit_IOS.h"
|
|
#include "Cafe/OS/libs/coreinit/coreinit_MEM.h"
|
|
#include "Cafe/IOSU/legacy/iosu_boss.h"
|
|
#include "Cafe/IOSU/legacy/iosu_act.h"
|
|
#include "config/ActiveSettings.h"
|
|
#include "Cafe/CafeSystem.h"
|
|
#include "Cafe/Filesystem/fsc.h"
|
|
|
|
namespace nn
|
|
{
|
|
typedef uint32 Result;
|
|
namespace boss
|
|
{
|
|
#define bossPrepareRequest() \
|
|
StackAllocator<iosuBossCemuRequest_t> _buf_bossRequest; \
|
|
StackAllocator<ioBufferVector_t> _buf_bufferVector; \
|
|
iosuBossCemuRequest_t* bossRequest = _buf_bossRequest.GetPointer(); \
|
|
ioBufferVector_t* bossBufferVector = _buf_bufferVector.GetPointer(); \
|
|
memset(bossRequest, 0, sizeof(iosuBossCemuRequest_t)); \
|
|
memset(bossBufferVector, 0, sizeof(ioBufferVector_t)); \
|
|
bossBufferVector->buffer = (uint8*)bossRequest;
|
|
|
|
coreinit::OSMutex g_mutex;
|
|
sint32 g_initCounter = 0;
|
|
bool g_isInitialized = false;
|
|
|
|
void freeMem(void* mem)
|
|
{
|
|
if(mem)
|
|
coreinit::default_MEMFreeToDefaultHeap((uint8*)mem - 8);
|
|
}
|
|
|
|
struct TaskSetting_t
|
|
{
|
|
static const uint32 kBossCode = 0x7C0;
|
|
static const uint32 kBossCodeLen = 0x20;
|
|
|
|
static const uint32 kDirectorySizeLimit = 0x7F0;
|
|
static const uint32 kDirectoryName = 0x7E0;
|
|
static const uint32 kDirectoryNameLen = 0x8;
|
|
|
|
//static const uint32 kFileName = 0x7F8;
|
|
static const uint32 kNbdlFileName = 0x7F8;
|
|
static const uint32 kFileNameLen = 0x20;
|
|
|
|
|
|
|
|
static const uint32 kURL = 0x48;
|
|
static const uint32 kURLLen = 0x100;
|
|
|
|
static const uint32 kClientCert = 0x41;
|
|
static const uint32 kCACert = 0x188;
|
|
|
|
static const uint32 kServiceToken = 0x590;
|
|
static const uint32 kServiceTokenLen = 0x200;
|
|
|
|
|
|
uint8 settings[0x1000];
|
|
uint32be uknExt_vTableProbably; // +0x1000
|
|
};
|
|
static_assert(sizeof(TaskSetting_t) == 0x1004);
|
|
static_assert(offsetof(TaskSetting_t, uknExt_vTableProbably) == 0x1000, "offsetof(TaskSetting_t, uknExt)");
|
|
|
|
struct NetTaskSetting_t : TaskSetting_t
|
|
{
|
|
// 0x188 cert1 + 0x188 cert2 + 0x188 cert3
|
|
// 0x190 AddCaCert (3times) char cert[0x80];
|
|
// SetConnectionSetting
|
|
// SetFirstLastModifiedTime
|
|
};
|
|
static_assert(sizeof(NetTaskSetting_t) == 0x1004);
|
|
|
|
struct NbdlTaskSetting_t : NetTaskSetting_t
|
|
{
|
|
//char fileName[0x20]; // @0x7F8
|
|
};
|
|
static_assert(sizeof(NbdlTaskSetting_t) == 0x1004);
|
|
|
|
struct RawUlTaskSetting_t : NetTaskSetting_t
|
|
{
|
|
static const uint32 kType = 0x12340000;
|
|
uint32be ukRaw1; // 0x1004
|
|
uint32be ukRaw2; // 0x1008
|
|
uint32be ukRaw3; // 0x100C
|
|
uint8 rawSpace[0x200]; // 0x1010
|
|
};
|
|
static_assert(sizeof(RawUlTaskSetting_t) == 0x1210);
|
|
|
|
struct PlayReportSetting_t : RawUlTaskSetting_t
|
|
{
|
|
static const uint32 kType = 0x12340001;
|
|
MEMPTR<void*> ukPlay1; // 0x1210
|
|
uint32be ukPlay2; // 0x1214
|
|
uint32be ukPlay3; // 0x1218
|
|
uint32be ukPlay4; // 0x121C
|
|
};
|
|
static_assert(sizeof(PlayReportSetting_t) == 0x1220);
|
|
|
|
struct RawDlTaskSetting_t : NetTaskSetting_t
|
|
{
|
|
static const uint32 kType = 0x12340002;
|
|
//char fileName[0x20]; // 0x7F8
|
|
};
|
|
static_assert(sizeof(RawDlTaskSetting_t) == 0x1004);
|
|
|
|
struct TitleId_t
|
|
{
|
|
uint64be u64{};
|
|
};
|
|
static_assert(sizeof(TitleId_t) == 8);
|
|
|
|
struct TaskId_t
|
|
{
|
|
char id[0x8]{};
|
|
};
|
|
static_assert(sizeof(TaskId_t) == 8);
|
|
|
|
struct Title_t
|
|
{
|
|
uint32be accountId{}; // 0x00
|
|
TitleId_t titleId{}; // 0x8
|
|
uint32be someValue = 0x12341000; // 0x10
|
|
};
|
|
static_assert(sizeof(Title_t) == 0x18);
|
|
|
|
struct DirectoryName_t
|
|
{
|
|
char name[0x8]{};
|
|
};
|
|
static_assert(sizeof(DirectoryName_t) == 8);
|
|
|
|
struct Account_t
|
|
{
|
|
uint32be accountId;
|
|
uint32be uk1; // global struct
|
|
};
|
|
static_assert(sizeof(Account_t) == 8);
|
|
|
|
struct Task_t
|
|
{
|
|
uint32be accountId; // 0x00
|
|
uint32be uk2; // 0x04
|
|
TaskId_t taskId; // 0x08
|
|
TitleId_t titleId; // 0x10
|
|
uint32be ext; // 0x18
|
|
uint32be padding; // 0x1C
|
|
};
|
|
static_assert(sizeof(Task_t) == 0x20, "sizeof(Task_t)");
|
|
|
|
namespace TaskId
|
|
{
|
|
TaskId_t* ctor(TaskId_t* thisptr)
|
|
{
|
|
if(!thisptr)
|
|
{
|
|
// thisptr = new TaskId_t
|
|
assert_dbg();
|
|
}
|
|
|
|
if(thisptr)
|
|
{
|
|
thisptr->id[0] = 0;
|
|
}
|
|
|
|
return thisptr;
|
|
}
|
|
}
|
|
|
|
namespace Account
|
|
{
|
|
Account_t* ctor(Account_t* thisptr, uint32 accountId)
|
|
{
|
|
if (!thisptr)
|
|
{
|
|
// thisptr = new TaskId_t
|
|
assert_dbg();
|
|
}
|
|
|
|
thisptr->accountId = accountId;
|
|
thisptr->uk1 = 0x12340010;
|
|
return thisptr;
|
|
}
|
|
}
|
|
|
|
namespace TitleId
|
|
{
|
|
TitleId_t* ctor(TitleId_t* thisptr, uint64 titleId)
|
|
{
|
|
if (!thisptr)
|
|
{
|
|
// thisptr = new TaskId_t
|
|
assert_dbg();
|
|
}
|
|
|
|
if (thisptr)
|
|
{
|
|
thisptr->u64 = titleId;
|
|
}
|
|
|
|
return thisptr;
|
|
}
|
|
|
|
TitleId_t* ctor(TitleId_t* thisptr)
|
|
{
|
|
return ctor(thisptr, 0);
|
|
}
|
|
|
|
bool IsValid(TitleId_t* thisptr)
|
|
{
|
|
return thisptr->u64 != 0;
|
|
}
|
|
|
|
TitleId_t* ctor1(TitleId_t* thisptr, uint32 filler, uint64 titleId)
|
|
{
|
|
return ctor(thisptr);
|
|
}
|
|
|
|
TitleId_t* ctor2(TitleId_t* thisptr, uint32 filler, uint64 titleId)
|
|
{
|
|
cemuLog_logDebug(LogType::Force, "nn_boss_TitleId_ctor2(0x{:x})", MEMPTR(thisptr).GetMPTR());
|
|
if (!thisptr)
|
|
{
|
|
// thisptr = new Task_t
|
|
assert_dbg();
|
|
}
|
|
|
|
thisptr->u64 = titleId;
|
|
return thisptr;
|
|
}
|
|
|
|
|
|
TitleId_t* cctor(TitleId_t* thisptr, TitleId_t* titleId)
|
|
{
|
|
cemuLog_logDebug(LogType::Force, "nn_boss_TitleId_cctor(0x{:x})", MEMPTR(thisptr).GetMPTR());
|
|
if (!thisptr)
|
|
{
|
|
// thisptr = new Task_t
|
|
assert_dbg();
|
|
}
|
|
|
|
thisptr->u64 = titleId->u64;
|
|
|
|
return thisptr;
|
|
}
|
|
|
|
bool operator_ne(TitleId_t* thisptr, TitleId_t* titleId)
|
|
{
|
|
cemuLog_logDebug(LogType::Force, "nn_boss_TitleId_operator_ne(0x{:x})", MEMPTR(thisptr).GetMPTR());
|
|
return thisptr->u64 != titleId->u64;
|
|
}
|
|
}
|
|
|
|
namespace TaskSetting
|
|
{
|
|
bool IsPrivilegedTaskSetting(TaskSetting_t* thisptr)
|
|
{
|
|
const uint16 value = *(uint16*)&thisptr->settings[0x28];
|
|
return value == 1 || value == 9 || value == 5;
|
|
}
|
|
|
|
void InitializeSetting(TaskSetting_t* thisptr)
|
|
{
|
|
memset(thisptr, 0x00, sizeof(TaskSetting_t::settings));
|
|
*(uint32*)&thisptr->settings[0x0C] = 0;
|
|
*(uint8*)&thisptr->settings[0x2A] = 0x7D; // timeout?
|
|
*(uint32*)&thisptr->settings[0x30] = 0x7080;
|
|
*(uint32*)&thisptr->settings[0x8] = 0;
|
|
*(uint32*)&thisptr->settings[0x38] = 0;
|
|
*(uint32*)&thisptr->settings[0x3C] = 0x76A700;
|
|
*(uint32*)&thisptr->settings[0] = 0x76A700;
|
|
}
|
|
|
|
TaskSetting_t* ctor(TaskSetting_t* thisptr)
|
|
{
|
|
if(!thisptr)
|
|
{
|
|
// thisptr = new TaskSetting_t
|
|
assert_dbg();
|
|
}
|
|
|
|
if (thisptr)
|
|
{
|
|
thisptr->uknExt_vTableProbably = 0;
|
|
InitializeSetting(thisptr);
|
|
}
|
|
|
|
return thisptr;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
namespace NetTaskSetting
|
|
{
|
|
Result AddCaCert(NetTaskSetting_t* thisptr, const char* name)
|
|
{
|
|
if(name == nullptr || strnlen(name, 0x80) == 0x80)
|
|
{
|
|
cemuLog_logDebug(LogType::Force, "nn_boss_NetTaskSetting_AddCaCert: name size is invalid");
|
|
return 0xC0203780;
|
|
}
|
|
|
|
cemu_assert_unimplemented();
|
|
|
|
return 0xA0220D00;
|
|
}
|
|
|
|
NetTaskSetting_t* ctor(NetTaskSetting_t* thisptr)
|
|
{
|
|
if (!thisptr)
|
|
{
|
|
// thisptr = new NetTaskSetting_t
|
|
assert_dbg();
|
|
}
|
|
|
|
if (thisptr)
|
|
{
|
|
TaskSetting::ctor(thisptr);
|
|
*(uint32*)&thisptr->settings[0x18C] = 0x78;
|
|
thisptr->uknExt_vTableProbably = 0;
|
|
}
|
|
|
|
return thisptr;
|
|
}
|
|
|
|
Result SetServiceToken(NetTaskSetting_t* thisptr, const uint8* serviceToken)
|
|
{
|
|
cemuLog_logDebug(LogType::Force, "nn_boss_NetTaskSetting_SetServiceToken(0x{:x}, 0x{:x})", MEMPTR(thisptr).GetMPTR(), MEMPTR(serviceToken).GetMPTR());
|
|
cemuLog_logDebug(LogType::Force, "\t->{}", fmt::ptr(serviceToken));
|
|
memcpy(&thisptr->settings[TaskSetting_t::kServiceToken], serviceToken, TaskSetting_t::kServiceTokenLen);
|
|
return 0x200080;
|
|
}
|
|
|
|
Result AddInternalCaCert(NetTaskSetting_t* thisptr, char certId)
|
|
{
|
|
cemuLog_logDebug(LogType::Force, "nn_boss_NetTaskSetting_AddInternalCaCert(0x{:x}, 0x{:x})", MEMPTR(thisptr).GetMPTR(), (int)certId);
|
|
|
|
uint32 location = TaskSetting_t::kCACert;
|
|
for(int i = 0; i < 3; ++i)
|
|
{
|
|
if(thisptr->settings[location] == 0)
|
|
{
|
|
thisptr->settings[location] = (uint8)certId;
|
|
return 0x200080;
|
|
}
|
|
|
|
location += TaskSetting_t::kCACert;
|
|
}
|
|
|
|
cemuLog_logDebug(LogType::Force, "nn_boss_NetTaskSetting_AddInternalCaCert: can't store certificate");
|
|
return 0xA0220D00;
|
|
}
|
|
|
|
void SetInternalClientCert(NetTaskSetting_t* thisptr, char certId)
|
|
{
|
|
cemuLog_logDebug(LogType::Force, "nn_boss_NetTaskSetting_SetInternalClientCert(0x{:x}, 0x{:x})", MEMPTR(thisptr).GetMPTR(), (int)certId);
|
|
thisptr->settings[TaskSetting_t::kClientCert] = (uint8)certId;
|
|
}
|
|
}
|
|
|
|
namespace NbdlTaskSetting // : NetTaskSetting
|
|
{
|
|
NbdlTaskSetting_t* ctor(NbdlTaskSetting_t* thisptr)
|
|
{
|
|
if (!thisptr)
|
|
{
|
|
// thisptr = new NbdlTaskSetting_t
|
|
assert_dbg();
|
|
}
|
|
|
|
if (thisptr)
|
|
{
|
|
NetTaskSetting::ctor(thisptr);
|
|
thisptr->uknExt_vTableProbably = 0;
|
|
}
|
|
|
|
return thisptr;
|
|
}
|
|
|
|
void export_ctor(PPCInterpreter_t* hCPU)
|
|
{
|
|
ppcDefineParamMEMPTR(thisptr, NbdlTaskSetting_t, 0);
|
|
cemuLog_logDebug(LogType::Force, "nn_boss_NbdlTaskSetting_ctor");
|
|
ctor(thisptr.GetPtr());
|
|
osLib_returnFromFunction(hCPU, thisptr.GetMPTR());
|
|
}
|
|
|
|
void export_Initialize(PPCInterpreter_t* hCPU)
|
|
{
|
|
ppcDefineParamMEMPTR(thisptr, NbdlTaskSetting_t, 0);
|
|
ppcDefineParamMEMPTR(bossCode, const char, 1);
|
|
ppcDefineParamU64(directorySizeLimit, 2);
|
|
ppcDefineParamMEMPTR(directoryName, const char, 4);
|
|
cemuLog_logDebug(LogType::Force, "nn_boss_NbdlTaskSetting_Initialize(0x{:08x}, {}, 0x{:x}, 0x{:08x})", thisptr.GetMPTR(), bossCode.GetPtr(), directorySizeLimit, directoryName.GetMPTR());
|
|
|
|
if(!bossCode || strnlen(bossCode.GetPtr(), 0x20) == 0x20)
|
|
{
|
|
osLib_returnFromFunction(hCPU, BUILD_NN_RESULT(NN_RESULT_LEVEL_LVL6, NN_RESULT_MODULE_NN_BOSS, 0x3780));
|
|
return;
|
|
}
|
|
|
|
if (directoryName && strnlen(directoryName.GetPtr(), 0x8) == 0x8)
|
|
{
|
|
osLib_returnFromFunction(hCPU, BUILD_NN_RESULT(NN_RESULT_LEVEL_LVL6, NN_RESULT_MODULE_NN_BOSS, 0x3780));
|
|
return;
|
|
}
|
|
|
|
strncpy((char*)&thisptr->settings[TaskSetting_t::kBossCode], bossCode.GetPtr(), TaskSetting_t::kBossCodeLen);
|
|
|
|
*(uint64be*)&thisptr->settings[TaskSetting_t::kDirectorySizeLimit] = directorySizeLimit; // uint64be
|
|
if(directoryName)
|
|
strncpy((char*)&thisptr->settings[TaskSetting_t::kDirectoryName], directoryName.GetPtr(), TaskSetting_t::kDirectoryNameLen);
|
|
|
|
osLib_returnFromFunction(hCPU, BUILD_NN_RESULT(NN_RESULT_LEVEL_SUCCESS, NN_RESULT_MODULE_NN_BOSS, 0x80));
|
|
}
|
|
|
|
Result SetFileName(NbdlTaskSetting_t* thisptr, const char* fileName)
|
|
{
|
|
cemuLog_logDebug(LogType::Force, "nn_boss_NbdlTaskSetting_t_SetFileName(0x{:08x}, {})", MEMPTR(thisptr).GetMPTR(), fileName ? fileName : "\"\"");
|
|
|
|
if (!fileName || strnlen(fileName, TaskSetting_t::kFileNameLen) == TaskSetting_t::kFileNameLen)
|
|
{
|
|
return BUILD_NN_RESULT(NN_RESULT_LEVEL_LVL6, NN_RESULT_MODULE_NN_BOSS, 0x3780);
|
|
}
|
|
|
|
strncpy((char*)&thisptr->settings[TaskSetting_t::kNbdlFileName], fileName, TaskSetting_t::kFileNameLen);
|
|
return BUILD_NN_RESULT(NN_RESULT_LEVEL_SUCCESS, NN_RESULT_MODULE_NN_BOSS, 0x80);
|
|
}
|
|
|
|
}
|
|
|
|
namespace RawUlTaskSetting
|
|
{
|
|
RawUlTaskSetting_t* ctor(RawUlTaskSetting_t* thisptr)
|
|
{
|
|
cemuLog_logDebug(LogType::Force, "nn_boss_RawUlTaskSetting_ctor(0x{:x}) TODO", MEMPTR(thisptr).GetMPTR());
|
|
if (!thisptr)
|
|
{
|
|
// thisptr = new RawUlTaskSetting_t
|
|
assert_dbg();
|
|
}
|
|
|
|
if (thisptr)
|
|
{
|
|
NetTaskSetting::ctor(thisptr);
|
|
thisptr->uknExt_vTableProbably = RawUlTaskSetting_t::kType;
|
|
thisptr->ukRaw1 = 0;
|
|
thisptr->ukRaw2 = 0;
|
|
thisptr->ukRaw3 = 0;
|
|
memset(thisptr->rawSpace, 0x00, 0x200);
|
|
}
|
|
|
|
return thisptr;
|
|
}
|
|
}
|
|
|
|
namespace RawDlTaskSetting
|
|
{
|
|
RawDlTaskSetting_t* ctor(RawDlTaskSetting_t* thisptr)
|
|
{
|
|
cemuLog_logDebug(LogType::Force, "nn_boss_RawDlTaskSetting_ctor(0x{:x}) TODO", MEMPTR(thisptr).GetMPTR());
|
|
if (!thisptr)
|
|
{
|
|
// thisptr = new RawDlTaskSetting_t
|
|
assert_dbg();
|
|
}
|
|
|
|
if (thisptr)
|
|
{
|
|
NetTaskSetting::ctor(thisptr);
|
|
thisptr->uknExt_vTableProbably = RawDlTaskSetting_t::kType;
|
|
}
|
|
|
|
return thisptr;
|
|
}
|
|
|
|
Result Initialize(RawDlTaskSetting_t* thisptr, const char* url, bool newArrival, bool led, const char* fileName, const char* directoryName)
|
|
{
|
|
cemuLog_logDebug(LogType::Force, "nn_boss_RawDlTaskSetting_Initialize(0x{:x}, 0x{:x}, {}, {}, 0x{:x}, 0x{:x})", MEMPTR(thisptr).GetMPTR(), MEMPTR(url).GetMPTR(), newArrival, led, MEMPTR(fileName).GetMPTR(), MEMPTR(directoryName).GetMPTR());
|
|
if (!url)
|
|
{
|
|
return 0xC0203780;
|
|
}
|
|
|
|
if (strnlen(url, TaskSetting_t::kURLLen) == TaskSetting_t::kURLLen)
|
|
{
|
|
return 0xC0203780;
|
|
}
|
|
|
|
cemuLog_logDebug(LogType::Force, "\t-> url: {}", url);
|
|
|
|
if (fileName && strnlen(fileName, TaskSetting_t::kFileNameLen) == TaskSetting_t::kFileNameLen)
|
|
{
|
|
return 0xC0203780;
|
|
}
|
|
|
|
if (directoryName && strnlen(directoryName, TaskSetting_t::kDirectoryNameLen) == TaskSetting_t::kDirectoryNameLen)
|
|
{
|
|
return 0xC0203780;
|
|
}
|
|
|
|
strncpy((char*)thisptr + TaskSetting_t::kURL, url, TaskSetting_t::kURLLen);
|
|
thisptr->settings[0x147] = '\0';
|
|
|
|
if (fileName)
|
|
strncpy((char*)thisptr + 0x7D0, fileName, TaskSetting_t::kFileNameLen);
|
|
else
|
|
strncpy((char*)thisptr + 0x7D0, "rawcontent.dat", TaskSetting_t::kFileNameLen);
|
|
thisptr->settings[0x7EF] = '\0';
|
|
|
|
cemuLog_logDebug(LogType::Force, "\t-> filename: {}", (char*)thisptr + 0x7D0);
|
|
|
|
if (directoryName)
|
|
{
|
|
strncpy((char*)thisptr + 0x7C8, directoryName, TaskSetting_t::kDirectoryNameLen);
|
|
thisptr->settings[0x7CF] = '\0';
|
|
cemuLog_logDebug(LogType::Force, "\t-> directoryName: {}", (char*)thisptr + 0x7C8);
|
|
}
|
|
|
|
thisptr->settings[0x7C0] = newArrival;
|
|
thisptr->settings[0x7C1] = led;
|
|
*(uint16be*)&thisptr->settings[0x28] = 0x3;
|
|
return 0x200080;
|
|
}
|
|
}
|
|
|
|
namespace PlayReportSetting // : NetTaskSetting
|
|
{
|
|
void export_ctor(PPCInterpreter_t* hCPU)
|
|
{
|
|
ppcDefineParamMEMPTR(thisptr, PlayReportSetting_t, 0);
|
|
cemuLog_logDebug(LogType::Force, "nn_boss_PlayReportSetting_ctor TODO");
|
|
if (!thisptr)
|
|
{
|
|
assert_dbg();
|
|
}
|
|
|
|
if (thisptr)
|
|
{
|
|
RawUlTaskSetting::ctor(thisptr.GetPtr());
|
|
thisptr->uknExt_vTableProbably = PlayReportSetting_t::kType;
|
|
thisptr->ukPlay1 = nullptr;
|
|
thisptr->ukPlay2 = 0;
|
|
thisptr->ukPlay3 = 0;
|
|
thisptr->ukPlay4 = 0;
|
|
}
|
|
|
|
osLib_returnFromFunction(hCPU, thisptr.GetMPTR());
|
|
}
|
|
|
|
void export_Initialize(PPCInterpreter_t* hCPU)
|
|
{
|
|
ppcDefineParamMEMPTR(thisptr, PlayReportSetting_t, 0);
|
|
ppcDefineParamMEMPTR(ptr, void*, 1);
|
|
ppcDefineParamU32(value, 2);
|
|
ppcDefineParamMEMPTR(directoryName, const char, 4);
|
|
//cemuLog_logDebug(LogType::Force, "nn_boss_PlayReportSetting_Initialize(0x{:08x}, {}, 0x{:x}, 0x{:08x})", thisptr.GetMPTR(), ptr.GetPtr(), directorySizeLimit, directoryName.GetMPTR());
|
|
|
|
if(!ptr || value == 0 || value > 0x19000)
|
|
{
|
|
cemuLog_logDebug(LogType::Force, "nn_boss_PlayReportSetting_Initialize: invalid parameter");
|
|
osLib_returnFromFunction(hCPU, 0);
|
|
}
|
|
|
|
*ptr.GetPtr<uint8>() = 0;
|
|
|
|
*(uint16be*)&thisptr->settings[0x28] = 6;
|
|
*(uint16be*)&thisptr->settings[0x2B] |= 0x3;
|
|
*(uint16be*)&thisptr->settings[0x2C] |= 0xA;
|
|
*(uint32be*)&thisptr->settings[0x7C0] |= 2;
|
|
|
|
thisptr->ukPlay1 = ptr;
|
|
thisptr->ukPlay2 = value;
|
|
thisptr->ukPlay3 = 0;
|
|
thisptr->ukPlay4 = 0;
|
|
|
|
// TODO
|
|
osLib_returnFromFunction(hCPU, 0);
|
|
}
|
|
|
|
void export_Set(PPCInterpreter_t* hCPU)
|
|
{
|
|
ppcDefineParamMEMPTR(thisptr, PlayReportSetting_t, 0);
|
|
ppcDefineParamMEMPTR(key, const char, 1);
|
|
ppcDefineParamU32(value, 2);
|
|
|
|
// TODO
|
|
cemuLog_logDebug(LogType::Force, "nn_boss_PlayReportSetting_Set(0x{:08x}, {}, 0x{:x}) TODO", thisptr.GetMPTR(), key.GetPtr(), value);
|
|
|
|
osLib_returnFromFunction(hCPU, 1);
|
|
}
|
|
|
|
|
|
}
|
|
|
|
namespace Title
|
|
{
|
|
Title_t* ctor(Title_t* thisptr)
|
|
{
|
|
cemuLog_logDebug(LogType::Force, "nn_boss_Title_ctor(0x{:x})", MEMPTR(thisptr).GetMPTR());
|
|
if (!thisptr)
|
|
{
|
|
// thisptr = new Task_t
|
|
assert_dbg();
|
|
}
|
|
|
|
*thisptr = {};
|
|
|
|
return thisptr;
|
|
}
|
|
}
|
|
|
|
namespace DirectoryName
|
|
{
|
|
DirectoryName_t* ctor(DirectoryName_t* thisptr)
|
|
{
|
|
cemuLog_logDebug(LogType::Force, "nn_boss_DirectoryName_ctor(0x{:x})", MEMPTR(thisptr).GetMPTR());
|
|
if (!thisptr)
|
|
{
|
|
// thisptr = new Task_t
|
|
assert_dbg();
|
|
}
|
|
|
|
memset(thisptr->name, 0x00, 0x8);
|
|
|
|
return thisptr;
|
|
}
|
|
|
|
const char* operator_const_char(DirectoryName_t* thisptr)
|
|
{
|
|
cemuLog_logDebug(LogType::Force, "nn_boss_DirectoryName_operator_const_char(0x{:x})", MEMPTR(thisptr).GetMPTR());
|
|
return thisptr->name;
|
|
}
|
|
}
|
|
|
|
namespace Task
|
|
{
|
|
|
|
Result Initialize(Task_t* thisptr, const char* taskId, uint32 accountId)
|
|
{
|
|
if(!taskId || strnlen(taskId, 0x8) == 8)
|
|
{
|
|
return BUILD_NN_RESULT(NN_RESULT_LEVEL_LVL6, NN_RESULT_MODULE_NN_BOSS, 0x3780);
|
|
}
|
|
|
|
thisptr->accountId = accountId;
|
|
strncpy(thisptr->taskId.id, taskId, 0x08);
|
|
return BUILD_NN_RESULT(NN_RESULT_LEVEL_SUCCESS, NN_RESULT_MODULE_NN_BOSS, 0x80);
|
|
}
|
|
|
|
Result Initialize(Task_t* thisptr, uint8 slot, const char* taskId)
|
|
{
|
|
const uint32 accountId = slot == 0 ? 0 : act::GetPersistentIdEx(slot);
|
|
return Initialize(thisptr, taskId, accountId);
|
|
}
|
|
|
|
Result Initialize(Task_t* thisptr, const char* taskId)
|
|
{
|
|
return Initialize(thisptr, taskId, 0);
|
|
}
|
|
|
|
void export_Initialize3(PPCInterpreter_t* hCPU)
|
|
{
|
|
ppcDefineParamMEMPTR(thisptr, Task_t, 0);
|
|
ppcDefineParamMEMPTR(taskId, const char, 1);
|
|
ppcDefineParamU32(accountId, 2);
|
|
cemuLog_logDebug(LogType::Force, "nn_boss_Task_Initialize3(0x{:08x}, {}, 0x{:x})", thisptr.GetMPTR(), taskId.GetPtr(), accountId);
|
|
const Result result = Initialize(thisptr.GetPtr(), taskId.GetPtr(), accountId);
|
|
osLib_returnFromFunction(hCPU, result);
|
|
}
|
|
|
|
void export_Initialize2(PPCInterpreter_t* hCPU)
|
|
{
|
|
ppcDefineParamMEMPTR(thisptr, Task_t, 0);
|
|
ppcDefineParamU8(slotId, 1);
|
|
ppcDefineParamMEMPTR(taskId, const char, 2);
|
|
cemuLog_logDebug(LogType::Force, "nn_boss_Task_Initialize2(0x{:08x}, {}, {})", thisptr.GetMPTR(), slotId, taskId.GetPtr());
|
|
const Result result = Initialize(thisptr.GetPtr(), slotId, taskId.GetPtr());
|
|
osLib_returnFromFunction(hCPU, result);
|
|
}
|
|
|
|
void export_Initialize1(PPCInterpreter_t* hCPU)
|
|
{
|
|
ppcDefineParamMEMPTR(thisptr, Task_t, 0);
|
|
ppcDefineParamMEMPTR(taskId, const char, 1);
|
|
cemuLog_logDebug(LogType::Force, "nn_boss_Task_Initialize1(0x{:08x}, {})", thisptr.GetMPTR(), taskId.GetPtr());
|
|
const Result result = Initialize(thisptr.GetPtr(), taskId.GetPtr());
|
|
osLib_returnFromFunction(hCPU, result);
|
|
}
|
|
|
|
|
|
Task_t* ctor(Task_t* thisptr, const char* taskId, uint32 accountId)
|
|
{
|
|
if (!thisptr)
|
|
{
|
|
// thisptr = new Task_t
|
|
assert_dbg();
|
|
}
|
|
|
|
if (thisptr)
|
|
{
|
|
thisptr->accountId = 0;
|
|
thisptr->ext = 0; // dword_10002174
|
|
TaskId::ctor(&thisptr->taskId);
|
|
TitleId::ctor(&thisptr->titleId, 0);
|
|
cemu_assert_debug(NN_RESULT_IS_SUCCESS(Initialize(thisptr, taskId, accountId)));
|
|
}
|
|
|
|
return thisptr;
|
|
}
|
|
|
|
Task_t* ctor(Task_t* thisptr, uint8 slot, const char* taskId)
|
|
{
|
|
if (!thisptr)
|
|
{
|
|
// thisptr = new Task_t
|
|
assert_dbg();
|
|
}
|
|
|
|
if (thisptr)
|
|
{
|
|
thisptr->accountId = 0;
|
|
thisptr->ext = 0; // dword_10002174
|
|
TaskId::ctor(&thisptr->taskId);
|
|
TitleId::ctor(&thisptr->titleId, 0);
|
|
cemu_assert_debug(NN_RESULT_IS_SUCCESS(Initialize(thisptr, slot, taskId)));
|
|
}
|
|
|
|
return thisptr;
|
|
}
|
|
|
|
Task_t* ctor(Task_t* thisptr, const char* taskId)
|
|
{
|
|
if (!thisptr)
|
|
{
|
|
// thisptr = new Task_t
|
|
assert_dbg();
|
|
}
|
|
|
|
if (thisptr)
|
|
{
|
|
thisptr->accountId = 0;
|
|
thisptr->ext = 0; // dword_10002174
|
|
TaskId::ctor(&thisptr->taskId);
|
|
TitleId::ctor(&thisptr->titleId, 0);
|
|
cemu_assert_debug(NN_RESULT_IS_SUCCESS(Initialize(thisptr, taskId)));
|
|
}
|
|
|
|
return thisptr;
|
|
}
|
|
|
|
Task_t* ctor(Task_t* thisptr)
|
|
{
|
|
if (!thisptr)
|
|
{
|
|
// thisptr = new Task_t
|
|
assert_dbg();
|
|
}
|
|
|
|
if (thisptr)
|
|
{
|
|
thisptr->accountId = 0;
|
|
thisptr->ext = 0; // dword_10002174
|
|
TaskId::ctor(&thisptr->taskId);
|
|
TitleId::ctor(&thisptr->titleId, 0);
|
|
memset(&thisptr->taskId, 0x00, sizeof(TaskId_t));
|
|
}
|
|
|
|
return thisptr;
|
|
}
|
|
|
|
void export_ctor(PPCInterpreter_t* hCPU)
|
|
{
|
|
ppcDefineParamMEMPTR(thisptr, Task_t, 0);
|
|
cemuLog_logDebug(LogType::Force, "nn_boss_Task_ctor(0x{:08x})", thisptr.GetMPTR());
|
|
ctor(thisptr.GetPtr());
|
|
osLib_returnFromFunction(hCPU, thisptr.GetMPTR());
|
|
}
|
|
|
|
void export_Run(PPCInterpreter_t* hCPU)
|
|
{
|
|
ppcDefineParamMEMPTR(thisptr, Task_t, 0);
|
|
ppcDefineParamU8(isForegroundRun, 1);
|
|
cemuLog_logDebug(LogType::Force, "nn_boss_Task_Run(0x{:08x}, {})", thisptr.GetMPTR(), isForegroundRun);
|
|
if (isForegroundRun != 0)
|
|
{
|
|
//peterBreak();
|
|
cemuLog_logDebug(LogType::Force, "export_Run foreground run");
|
|
}
|
|
|
|
bossPrepareRequest();
|
|
bossRequest->requestCode = IOSU_NN_BOSS_TASK_RUN;
|
|
bossRequest->accountId = thisptr->accountId;
|
|
bossRequest->taskId = thisptr->taskId.id;
|
|
bossRequest->titleId = thisptr->titleId.u64;
|
|
bossRequest->bool_parameter = isForegroundRun != 0;
|
|
|
|
__depr__IOS_Ioctlv(IOS_DEVICE_BOSS, IOSU_BOSS_REQUEST_CEMU, 1, 1, bossBufferVector);
|
|
|
|
osLib_returnFromFunction(hCPU, 0);
|
|
}
|
|
|
|
void export_StartScheduling(PPCInterpreter_t* hCPU)
|
|
{
|
|
ppcDefineParamMEMPTR(thisptr, Task_t, 0);
|
|
ppcDefineParamU8(executeImmediately, 1);
|
|
cemuLog_logDebug(LogType::Force, "nn_boss_Task_StartScheduling(0x{:08x}, {})", thisptr.GetMPTR(), executeImmediately);
|
|
|
|
bossPrepareRequest();
|
|
bossRequest->requestCode = IOSU_NN_BOSS_TASK_START_SCHEDULING;
|
|
bossRequest->accountId = thisptr->accountId;
|
|
bossRequest->taskId = thisptr->taskId.id;
|
|
bossRequest->titleId = thisptr->titleId.u64;
|
|
bossRequest->bool_parameter = executeImmediately != 0;
|
|
|
|
__depr__IOS_Ioctlv(IOS_DEVICE_BOSS, IOSU_BOSS_REQUEST_CEMU, 1, 1, bossBufferVector);
|
|
|
|
osLib_returnFromFunction(hCPU, 0);
|
|
}
|
|
|
|
void export_StopScheduling(PPCInterpreter_t* hCPU)
|
|
{
|
|
ppcDefineParamMEMPTR(thisptr, Task_t, 0);
|
|
cemuLog_logDebug(LogType::Force, "nn_boss_Task_StopScheduling(0x{:08x})", thisptr.GetMPTR());
|
|
|
|
bossPrepareRequest();
|
|
bossRequest->requestCode = IOSU_NN_BOSS_TASK_STOP_SCHEDULING;
|
|
bossRequest->accountId = thisptr->accountId;
|
|
bossRequest->taskId = thisptr->taskId.id;
|
|
bossRequest->titleId = thisptr->titleId.u64;
|
|
|
|
__depr__IOS_Ioctlv(IOS_DEVICE_BOSS, IOSU_BOSS_REQUEST_CEMU, 1, 1, bossBufferVector);
|
|
|
|
osLib_returnFromFunction(hCPU, 0);
|
|
}
|
|
|
|
void export_IsRegistered(PPCInterpreter_t* hCPU)
|
|
{
|
|
ppcDefineParamMEMPTR(thisptr, Task_t, 0);
|
|
|
|
bossPrepareRequest();
|
|
bossRequest->requestCode = IOSU_NN_BOSS_TASK_IS_REGISTERED;
|
|
bossRequest->accountId = thisptr->accountId;
|
|
bossRequest->titleId = thisptr->titleId.u64;
|
|
bossRequest->taskId = thisptr->taskId.id;
|
|
|
|
__depr__IOS_Ioctlv(IOS_DEVICE_BOSS, IOSU_BOSS_REQUEST_CEMU, 1, 1, bossBufferVector);
|
|
|
|
cemuLog_logDebug(LogType::Force, "nn_boss_Task_IsRegistered(0x{:08x}) -> {}", thisptr.GetMPTR(), bossRequest->returnCode);
|
|
|
|
osLib_returnFromFunction(hCPU, bossRequest->returnCode);
|
|
}
|
|
|
|
void export_Wait(PPCInterpreter_t* hCPU)
|
|
{
|
|
// Wait__Q3_2nn4boss4TaskFUiQ3_2nn4boss13TaskWaitState
|
|
ppcDefineParamMEMPTR(thisptr, Task_t, 0);
|
|
ppcDefineParamU32(timeout, 1);
|
|
ppcDefineParamU32(waitState, 2);
|
|
cemuLog_logDebug(LogType::Force, "nn_boss_Task_Wait(0x{:08x}, 0x{:x}, {})", thisptr.GetMPTR(), timeout, waitState);
|
|
|
|
bossPrepareRequest();
|
|
bossRequest->requestCode = IOSU_NN_BOSS_TASK_WAIT;
|
|
bossRequest->titleId = thisptr->titleId.u64;
|
|
bossRequest->taskId = thisptr->taskId.id;
|
|
bossRequest->timeout = timeout;
|
|
bossRequest->waitState = waitState;
|
|
|
|
__depr__IOS_Ioctlv(IOS_DEVICE_BOSS, IOSU_BOSS_REQUEST_CEMU, 1, 1, bossBufferVector);
|
|
|
|
osLib_returnFromFunction(hCPU, bossRequest->returnCode);
|
|
|
|
//osLib_returnFromFunction(hCPU, 1); // 0 -> timeout, 1 -> wait condition met
|
|
}
|
|
|
|
void export_RegisterForImmediateRun(PPCInterpreter_t* hCPU)
|
|
{
|
|
// RegisterForImmediateRun__Q3_2nn4boss4TaskFRCQ3_2nn4boss11TaskSetting
|
|
ppcDefineParamMEMPTR(thisptr, Task_t, 0);
|
|
ppcDefineParamMEMPTR(settings, TaskSetting_t, 1);
|
|
cemuLog_logDebug(LogType::Force, "nn_boss_Task_RegisterForImmediateRun(0x{:08x}, 0x{:08x})", thisptr.GetMPTR(), settings.GetMPTR());
|
|
|
|
bossPrepareRequest();
|
|
bossRequest->requestCode = IOSU_NN_BOSS_TASK_REGISTER;
|
|
bossRequest->accountId = thisptr->accountId;
|
|
bossRequest->taskId = thisptr->taskId.id;
|
|
bossRequest->settings = settings.GetPtr();
|
|
bossRequest->uk1 = 0xC00;
|
|
|
|
if (TaskSetting::IsPrivilegedTaskSetting(settings.GetPtr()))
|
|
bossRequest->titleId = thisptr->titleId.u64;
|
|
|
|
const sint32 result = __depr__IOS_Ioctlv(IOS_DEVICE_BOSS, IOSU_BOSS_REQUEST_CEMU, 1, 1, bossBufferVector);
|
|
osLib_returnFromFunction(hCPU, result);
|
|
}
|
|
|
|
void export_Unregister(PPCInterpreter_t* hCPU)
|
|
{
|
|
ppcDefineParamMEMPTR(thisptr, Task_t, 0);
|
|
cemuLog_logDebug(LogType::Force, "nn_boss_Task_Unregister(0x{:08x})", thisptr.GetMPTR());
|
|
|
|
bossPrepareRequest();
|
|
bossRequest->requestCode = IOSU_NN_BOSS_TASK_UNREGISTER;
|
|
bossRequest->accountId = thisptr->accountId;
|
|
bossRequest->taskId = thisptr->taskId.id;
|
|
bossRequest->titleId = thisptr->titleId.u64;
|
|
|
|
const sint32 result = __depr__IOS_Ioctlv(IOS_DEVICE_BOSS, IOSU_BOSS_REQUEST_CEMU, 1, 1, bossBufferVector);
|
|
osLib_returnFromFunction(hCPU, result);
|
|
}
|
|
|
|
void export_Register(PPCInterpreter_t* hCPU)
|
|
{
|
|
ppcDefineParamMEMPTR(thisptr, Task_t, 0);
|
|
ppcDefineParamMEMPTR(settings, TaskSetting_t, 1);
|
|
cemuLog_logDebug(LogType::Force, "nn_boss_Task_Register(0x{:08x}, 0x{:08x})", thisptr.GetMPTR(), settings.GetMPTR());
|
|
|
|
if (hCPU->gpr[4] == 0)
|
|
{
|
|
cemuLog_logDebug(LogType::Force, "nn_boss_Task_Register - crash workaround (fix me)");
|
|
osLib_returnFromFunction(hCPU, 0);
|
|
return;
|
|
}
|
|
|
|
bossPrepareRequest();
|
|
bossRequest->requestCode = IOSU_NN_BOSS_TASK_REGISTER_FOR_IMMEDIATE_RUN;
|
|
bossRequest->accountId = thisptr->accountId;
|
|
bossRequest->taskId = thisptr->taskId.id;
|
|
bossRequest->settings = settings.GetPtr();
|
|
bossRequest->uk1 = 0xC00;
|
|
|
|
if(TaskSetting::IsPrivilegedTaskSetting(settings.GetPtr()))
|
|
bossRequest->titleId = thisptr->titleId.u64;
|
|
|
|
__depr__IOS_Ioctlv(IOS_DEVICE_BOSS, IOSU_BOSS_REQUEST_CEMU, 1, 1, bossBufferVector);
|
|
|
|
osLib_returnFromFunction(hCPU, bossRequest->returnCode);
|
|
}
|
|
|
|
|
|
void export_GetTurnState(PPCInterpreter_t* hCPU)
|
|
{
|
|
ppcDefineParamMEMPTR(thisptr, Task_t, 0);
|
|
ppcDefineParamMEMPTR(execCount, uint32be, 1);
|
|
|
|
bossPrepareRequest();
|
|
bossRequest->requestCode = IOSU_NN_BOSS_TASK_GET_TURN_STATE;
|
|
bossRequest->accountId = thisptr->accountId;
|
|
bossRequest->taskId = thisptr->taskId.id;
|
|
bossRequest->titleId = thisptr->titleId.u64;
|
|
|
|
__depr__IOS_Ioctlv(IOS_DEVICE_BOSS, IOSU_BOSS_REQUEST_CEMU, 1, 1, bossBufferVector);
|
|
|
|
if (execCount)
|
|
*execCount = bossRequest->u32.exec_count;
|
|
|
|
cemuLog_logDebug(LogType::Force, "nn_boss_Task_GetTurnState(0x{:08x}, 0x{:08x}) -> {}", thisptr.GetMPTR(), execCount.GetMPTR(), bossRequest->u32.result);
|
|
|
|
osLib_returnFromFunction(hCPU, bossRequest->u32.result);
|
|
//osLib_returnFromFunction(hCPU, 7); // 7 -> finished? 0x11 -> Error (Splatoon doesn't like it when we return 0x11 for Nbdl tasks) RETURN FINISHED
|
|
}
|
|
|
|
void export_GetContentLength(PPCInterpreter_t* hCPU)
|
|
{
|
|
ppcDefineParamMEMPTR(thisptr, Task_t, 0);
|
|
ppcDefineParamMEMPTR(execCount, uint32be, 1);
|
|
|
|
bossPrepareRequest();
|
|
bossRequest->requestCode = IOSU_NN_BOSS_TASK_GET_CONTENT_LENGTH;
|
|
bossRequest->accountId = thisptr->accountId;
|
|
bossRequest->taskId = thisptr->taskId.id;
|
|
bossRequest->titleId = thisptr->titleId.u64;
|
|
|
|
__depr__IOS_Ioctlv(IOS_DEVICE_BOSS, IOSU_BOSS_REQUEST_CEMU, 1, 1, bossBufferVector);
|
|
|
|
if (execCount)
|
|
*execCount = bossRequest->u64.exec_count;
|
|
|
|
cemuLog_logDebug(LogType::Force, "nn_boss_Task_GetContentLength(0x{:08x}, 0x{:08x}) -> 0x{:x}", thisptr.GetMPTR(), execCount.GetMPTR(), bossRequest->u64.result);
|
|
|
|
osLib_returnFromFunction64(hCPU, bossRequest->u64.result);
|
|
}
|
|
|
|
void export_GetProcessedLength(PPCInterpreter_t* hCPU)
|
|
{
|
|
ppcDefineParamMEMPTR(thisptr, Task_t, 0);
|
|
ppcDefineParamMEMPTR(execCount, uint32be, 1);
|
|
|
|
bossPrepareRequest();
|
|
bossRequest->requestCode = IOSU_NN_BOSS_TASK_GET_PROCESSED_LENGTH;
|
|
bossRequest->accountId = thisptr->accountId;
|
|
bossRequest->taskId = thisptr->taskId.id;
|
|
bossRequest->titleId = thisptr->titleId.u64;
|
|
|
|
__depr__IOS_Ioctlv(IOS_DEVICE_BOSS, IOSU_BOSS_REQUEST_CEMU, 1, 1, bossBufferVector);
|
|
|
|
if (execCount)
|
|
*execCount = bossRequest->u64.exec_count;
|
|
|
|
cemuLog_logDebug(LogType::Force, "nn_boss_Task_GetProcessedLength(0x{:08x}, 0x{:08x}) -> 0x{:x}", thisptr.GetMPTR(), execCount.GetMPTR(), bossRequest->u64.result);
|
|
|
|
osLib_returnFromFunction64(hCPU, bossRequest->u64.result);
|
|
}
|
|
|
|
void export_GetHttpStatusCode(PPCInterpreter_t* hCPU)
|
|
{
|
|
ppcDefineParamMEMPTR(thisptr, Task_t, 0);
|
|
ppcDefineParamMEMPTR(execCount, uint32be, 1);
|
|
|
|
bossPrepareRequest();
|
|
bossRequest->requestCode = IOSU_NN_BOSS_TASK_GET_HTTP_STATUS_CODE;
|
|
bossRequest->accountId = thisptr->accountId;
|
|
bossRequest->taskId = thisptr->taskId.id;
|
|
bossRequest->titleId = thisptr->titleId.u64;
|
|
|
|
__depr__IOS_Ioctlv(IOS_DEVICE_BOSS, IOSU_BOSS_REQUEST_CEMU, 1, 1, bossBufferVector);
|
|
|
|
if (execCount)
|
|
*execCount = bossRequest->u32.exec_count;
|
|
|
|
cemuLog_logDebug(LogType::Force, "nn_boss_Task_GetHttpStatusCode(0x{:08x}, 0x{:08x}) -> {}", thisptr.GetMPTR(), execCount.GetMPTR(), bossRequest->u32.result);
|
|
|
|
osLib_returnFromFunction(hCPU, bossRequest->u32.result);
|
|
}
|
|
}
|
|
|
|
struct PrivilegedTask_t : Task_t
|
|
{
|
|
|
|
};
|
|
static_assert(sizeof(PrivilegedTask_t) == 0x20);
|
|
|
|
struct AlmightyTask_t : PrivilegedTask_t
|
|
{
|
|
|
|
};
|
|
static_assert(sizeof(AlmightyTask_t) == 0x20);
|
|
|
|
namespace PrivilegedTask
|
|
{
|
|
PrivilegedTask_t* ctor(PrivilegedTask_t*thisptr)
|
|
{
|
|
if (!thisptr)
|
|
assert_dbg(); // new
|
|
|
|
Task::ctor(thisptr);
|
|
thisptr->ext = 0x10003a50;
|
|
return thisptr;
|
|
}
|
|
}
|
|
|
|
namespace AlmightyTask
|
|
{
|
|
AlmightyTask_t* ctor(AlmightyTask_t* thisptr)
|
|
{
|
|
if (!thisptr)
|
|
assert_dbg(); // new
|
|
|
|
PrivilegedTask::ctor(thisptr);
|
|
thisptr->ext = 0x10002a0c;
|
|
return thisptr;
|
|
}
|
|
void dtor(AlmightyTask_t* thisptr)
|
|
{
|
|
if (thisptr)
|
|
freeMem(thisptr);
|
|
}
|
|
|
|
uint32 Initialize(AlmightyTask_t* thisptr, TitleId_t* titleId, const char* taskId, uint32 accountId)
|
|
{
|
|
if (!thisptr)
|
|
return 0xc0203780;
|
|
|
|
thisptr->accountId = accountId;
|
|
thisptr->titleId.u64 = titleId->u64;
|
|
strncpy(thisptr->taskId.id, taskId, 8);
|
|
thisptr->taskId.id[7] = 0x00;
|
|
|
|
return 0x200080;
|
|
}
|
|
}
|
|
|
|
Result InitializeImpl()
|
|
{
|
|
// if( Initialize(IpcClientCafe*) ) ...
|
|
g_isInitialized = true;
|
|
return 0;
|
|
}
|
|
|
|
void export_IsInitialized(PPCInterpreter_t* hCPU)
|
|
{
|
|
osLib_returnFromFunction(hCPU, (uint32)g_isInitialized);
|
|
}
|
|
|
|
Result Initialize()
|
|
{
|
|
Result result;
|
|
coreinit::OSLockMutex(&g_mutex);
|
|
|
|
if(g_initCounter != 0 || NN_RESULT_IS_SUCCESS((result=InitializeImpl())))
|
|
{
|
|
g_initCounter++;
|
|
result = 0;
|
|
}
|
|
|
|
coreinit::OSUnlockMutex(&g_mutex);
|
|
return result;
|
|
}
|
|
|
|
void export_Initialize(PPCInterpreter_t* hCPU)
|
|
{
|
|
cemuLog_logDebug(LogType::Force, "nn_boss_Initialize()");
|
|
osLib_returnFromFunction(hCPU, Initialize());
|
|
}
|
|
|
|
void export_GetBossState(PPCInterpreter_t* hCPU)
|
|
{
|
|
cemuLog_logDebug(LogType::Force, "nn_boss.GetBossState() - stub");
|
|
osLib_returnFromFunction(hCPU, 7);
|
|
}
|
|
|
|
enum StorageKind
|
|
{
|
|
kStorageKind_NBDL,
|
|
kStorageKind_RawDl,
|
|
};
|
|
|
|
namespace Storage
|
|
{
|
|
struct bossStorage_t
|
|
{
|
|
/* +0x00 */ uint32be accountId;
|
|
/* +0x04 */ uint32be storageKind;
|
|
/* +0x08 */ uint8 ukn08Array[3];
|
|
/* +0x0B */ char storageName[8];
|
|
uint8 ukn13;
|
|
uint8 ukn14;
|
|
uint8 ukn15;
|
|
uint8 ukn16;
|
|
uint8 ukn17;
|
|
/* +0x18 */
|
|
nn::boss::TitleId_t titleId;
|
|
uint32be ukn20; // pointer to some global struct
|
|
uint32be ukn24;
|
|
};
|
|
|
|
static_assert(sizeof(bossStorage_t) == 0x28);
|
|
static_assert(offsetof(bossStorage_t, storageKind) == 0x04);
|
|
static_assert(offsetof(bossStorage_t, ukn08Array) == 0x08);
|
|
static_assert(offsetof(bossStorage_t, storageName) == 0x0B);
|
|
static_assert(offsetof(bossStorage_t, titleId) == 0x18);
|
|
|
|
bossStorage_t* ctor(bossStorage_t* thisptr)
|
|
{
|
|
cemuLog_logDebug(LogType::Force, "nn_boss_Storage_ctor(0x{:x})", MEMPTR(thisptr).GetMPTR());
|
|
if (!thisptr)
|
|
{
|
|
// thisptr = new RawDlTaskSetting_t
|
|
assert_dbg();
|
|
}
|
|
|
|
if (thisptr)
|
|
{
|
|
thisptr->titleId.u64 = 0;
|
|
thisptr->ukn20 = 0x10000a64;
|
|
}
|
|
|
|
return thisptr;
|
|
}
|
|
|
|
void nnBossStorage_prepareTitleId(bossStorage_t* storage)
|
|
{
|
|
if (storage->titleId.u64 != 0)
|
|
return;
|
|
storage->titleId.u64 = CafeSystem::GetForegroundTitleId();
|
|
}
|
|
|
|
Result Initialize(bossStorage_t* thisptr, const char* dirName, uint32 accountId, StorageKind type)
|
|
{
|
|
if (!dirName)
|
|
return 0xC0203780;
|
|
|
|
cemuLog_logDebug(LogType::Force, "boss::Storage::Initialize({}, 0x{:08x}, {})", dirName, accountId, type);
|
|
|
|
thisptr->storageKind = type;
|
|
thisptr->titleId.u64 = 0;
|
|
|
|
memset(thisptr->storageName, 0, 0x8);
|
|
strncpy(thisptr->storageName, dirName, 0x8);
|
|
thisptr->storageName[7] = '\0';
|
|
|
|
thisptr->accountId = accountId;
|
|
|
|
nnBossStorage_prepareTitleId(thisptr); // usually not done like this
|
|
|
|
return 0x200080;
|
|
}
|
|
|
|
Result Initialize2(bossStorage_t* thisptr, const char* dirName, StorageKind type)
|
|
{
|
|
return Initialize(thisptr, dirName, 0, type);
|
|
}
|
|
}
|
|
|
|
using Storage_t = Storage::bossStorage_t;
|
|
struct AlmightyStorage_t : Storage_t
|
|
{
|
|
};
|
|
static_assert(sizeof(AlmightyStorage_t) == 0x28);
|
|
|
|
namespace AlmightyStorage
|
|
{
|
|
AlmightyStorage_t* ctor(AlmightyStorage_t* thisptr)
|
|
{
|
|
cemuLog_logDebug(LogType::Force, "nn_boss_AlmightyStorage_ctor(0x{:x})", MEMPTR(thisptr).GetMPTR());
|
|
if (!thisptr)
|
|
{
|
|
// thisptr = new RawDlTaskSetting_t
|
|
assert_dbg();
|
|
}
|
|
|
|
if (thisptr)
|
|
{
|
|
Storage::ctor(thisptr);
|
|
thisptr->ukn20 = 0x100028a4;
|
|
}
|
|
|
|
return thisptr;
|
|
}
|
|
|
|
uint32 Initialize(AlmightyStorage_t* thisptr, TitleId_t* titleId, const char* storageName, uint32 accountId, StorageKind storageKind)
|
|
{
|
|
cemuLog_logDebug(LogType::Force, "nn_boss_AlmightyStorage_Initialize(0x{:x})", MEMPTR(thisptr).GetMPTR());
|
|
if (!thisptr)
|
|
return 0xc0203780;
|
|
|
|
thisptr->accountId = accountId;
|
|
thisptr->storageKind = storageKind;
|
|
thisptr->titleId.u64 = titleId->u64;
|
|
|
|
strncpy(thisptr->storageName, storageName, 8);
|
|
thisptr->storageName[0x7] = 0x00;
|
|
|
|
return 0x200080;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Storage
|
|
|
|
struct bossDataName_t
|
|
{
|
|
char name[32];
|
|
};
|
|
|
|
static_assert(sizeof(bossDataName_t) == 0x20);
|
|
|
|
struct bossStorageFadEntry_t
|
|
{
|
|
char name[32];
|
|
uint32be fileNameId;
|
|
uint32 ukn24;
|
|
uint32 ukn28;
|
|
uint32 ukn2C;
|
|
uint32 ukn30;
|
|
uint32be timestampRelated; // guessed
|
|
};
|
|
|
|
// __ct__Q3_2nn4boss8DataNameFv
|
|
void nnBossDataNameExport_ct(PPCInterpreter_t* hCPU)
|
|
{
|
|
ppcDefineParamStructPtr(dataName, bossDataName_t, 0);
|
|
memset(dataName, 0, sizeof(bossDataName_t));
|
|
osLib_returnFromFunction(hCPU, memory_getVirtualOffsetFromPointer(dataName));
|
|
}
|
|
|
|
// __opPCc__Q3_2nn4boss8DataNameCFv
|
|
void nnBossDataNameExport_opPCc(PPCInterpreter_t* hCPU)
|
|
{
|
|
ppcDefineParamStructPtr(dataName, bossDataName_t, 0);
|
|
osLib_returnFromFunction(hCPU, memory_getVirtualOffsetFromPointer(dataName->name));
|
|
}
|
|
|
|
void nnBossStorageExport_ct(PPCInterpreter_t* hCPU)
|
|
{
|
|
ppcDefineParamStructPtr(storage, nn::boss::Storage::bossStorage_t, 0);
|
|
cemuLog_logDebug(LogType::Force, "Constructor for boss storage called");
|
|
// todo
|
|
memset(storage, 0, sizeof(nn::boss::Storage::bossStorage_t));
|
|
osLib_returnFromFunction(hCPU, memory_getVirtualOffsetFromPointer(storage));
|
|
}
|
|
|
|
void nnBossStorageExport_exist(PPCInterpreter_t* hCPU)
|
|
{
|
|
ppcDefineParamStructPtr(storage, nn::boss::Storage::bossStorage_t, 0);
|
|
cemuLog_logDebug(LogType::Force, "nn_boss.Storage_Exist(...) TODO");
|
|
|
|
// todo
|
|
osLib_returnFromFunction(hCPU, 1);
|
|
}
|
|
|
|
#define FAD_ENTRY_MAX_COUNT 512
|
|
|
|
FSCVirtualFile* nnBossStorageFile_open(nn::boss::Storage::bossStorage_t* storage, uint32 fileNameId)
|
|
{
|
|
char storageFilePath[1024];
|
|
sprintf(storageFilePath, "/cemuBossStorage/%08x/%08x/user/common/data/%s/%08x", (uint32)(storage->titleId.u64 >> 32), (uint32)(storage->titleId.u64), storage->storageName, fileNameId);
|
|
sint32 fscStatus;
|
|
FSCVirtualFile* fscStorageFile = fsc_open(storageFilePath, FSC_ACCESS_FLAG::OPEN_FILE | FSC_ACCESS_FLAG::READ_PERMISSION | FSC_ACCESS_FLAG::WRITE_PERMISSION, &fscStatus);
|
|
return fscStorageFile;
|
|
}
|
|
|
|
bossStorageFadEntry_t* nnBossStorageFad_getTable(nn::boss::Storage::bossStorage_t* storage)
|
|
{
|
|
const auto accountId = ActiveSettings::GetPersistentId();
|
|
char fadPath[1024];
|
|
sprintf(fadPath, "/cemuBossStorage/%08x/%08x/user/common/%08x/%s/fad.db", (uint32)(storage->titleId.u64 >> 32), (uint32)(storage->titleId.u64), accountId, storage->storageName);
|
|
|
|
sint32 fscStatus;
|
|
FSCVirtualFile* fscFadFile = fsc_open(fadPath, FSC_ACCESS_FLAG::OPEN_FILE | FSC_ACCESS_FLAG::READ_PERMISSION, &fscStatus);
|
|
if (!fscFadFile)
|
|
{
|
|
return nullptr;
|
|
}
|
|
// skip first 8 bytes
|
|
fsc_setFileSeek(fscFadFile, 8);
|
|
// read entries
|
|
bossStorageFadEntry_t* fadTable = (bossStorageFadEntry_t*)malloc(sizeof(bossStorageFadEntry_t)*FAD_ENTRY_MAX_COUNT);
|
|
memset(fadTable, 0, sizeof(bossStorageFadEntry_t)*FAD_ENTRY_MAX_COUNT);
|
|
fsc_readFile(fscFadFile, fadTable, sizeof(bossStorageFadEntry_t)*FAD_ENTRY_MAX_COUNT);
|
|
fsc_close(fscFadFile);
|
|
return fadTable;
|
|
}
|
|
|
|
// Find index of entry by name. Returns -1 if not found
|
|
sint32 nnBossStorageFad_getIndexByName(bossStorageFadEntry_t* fadTable, char* name)
|
|
{
|
|
for (sint32 i = 0; i < FAD_ENTRY_MAX_COUNT; i++)
|
|
{
|
|
if (fadTable[i].name[0] == '\0')
|
|
continue;
|
|
if (strncmp(name, fadTable[i].name, 0x20) == 0)
|
|
{
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
bool nnBossStorageFad_getEntryByName(nn::boss::Storage::bossStorage_t* storage, char* name, bossStorageFadEntry_t* fadEntry)
|
|
{
|
|
bossStorageFadEntry_t* fadTable = nnBossStorageFad_getTable(storage);
|
|
if (fadTable)
|
|
{
|
|
sint32 entryIndex = nnBossStorageFad_getIndexByName(fadTable, name);
|
|
if (entryIndex >= 0)
|
|
{
|
|
memcpy(fadEntry, fadTable + entryIndex, sizeof(bossStorageFadEntry_t));
|
|
free(fadTable);
|
|
return true;
|
|
}
|
|
free(fadTable);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void nnBossStorageExport_getDataList(PPCInterpreter_t* hCPU)
|
|
{
|
|
ppcDefineParamStructPtr(storage, nn::boss::Storage::bossStorage_t, 0);
|
|
ppcDefineParamStructPtr(dataList, bossDataName_t, 1);
|
|
ppcDefineParamS32(maxEntries, 2);
|
|
ppcDefineParamU32BEPtr(outputEntryCount, 3);
|
|
cemuLog_logDebug(LogType::Force, "boss storage getDataList()");
|
|
|
|
// initialize titleId of storage if not already done
|
|
nnBossStorage_prepareTitleId(storage);
|
|
|
|
// load fad.db
|
|
bossStorageFadEntry_t* fadTable = nnBossStorageFad_getTable(storage);
|
|
if (fadTable)
|
|
{
|
|
sint32 validEntryCount = 0;
|
|
for (sint32 i = 0; i < FAD_ENTRY_MAX_COUNT; i++)
|
|
{
|
|
if( fadTable[i].name[0] == '\0' )
|
|
continue;
|
|
memcpy(dataList[validEntryCount].name, fadTable[i].name, 0x20);
|
|
validEntryCount++;
|
|
if (validEntryCount >= maxEntries)
|
|
break;
|
|
}
|
|
*outputEntryCount = validEntryCount;
|
|
free(fadTable);
|
|
}
|
|
else
|
|
{
|
|
// could not load fad table
|
|
*outputEntryCount = 0;
|
|
}
|
|
osLib_returnFromFunction(hCPU, 0); // error code
|
|
}
|
|
|
|
// NsData
|
|
|
|
typedef struct
|
|
{
|
|
/* +0x00 */ char name[0x20];
|
|
/* +0x20 */ nn::boss::Storage::bossStorage_t storage;
|
|
/* +0x48 */ uint64 readIndex;
|
|
/* +0x50 */ uint32 ukn50; // some pointer to a global struct
|
|
/* +0x54 */ uint32 ukn54;
|
|
}nsData_t;
|
|
|
|
void nnBossNsDataExport_ct(PPCInterpreter_t* hCPU)
|
|
{
|
|
cemuLog_logDebug(LogType::Force, "nnBossNsDataExport_ct");
|
|
ppcDefineParamStructPtr(nsData, nsData_t, 0);
|
|
if (!nsData)
|
|
assert_dbg();
|
|
|
|
|
|
nsData->ukn50 = 0x10000530;
|
|
|
|
memset(nsData->name, 0, 0x20);
|
|
|
|
nsData->storage.ukn20 = 0x10000798;
|
|
nsData->storage.titleId.u64 = 0;
|
|
|
|
nsData->readIndex = 0;
|
|
|
|
osLib_returnFromFunction(hCPU, memory_getVirtualOffsetFromPointer(nsData));
|
|
}
|
|
|
|
void nnBossNsDataExport_initialize(PPCInterpreter_t* hCPU)
|
|
{
|
|
ppcDefineParamStructPtr(nsData, nsData_t, 0);
|
|
ppcDefineParamStructPtr(storage, nn::boss::Storage::bossStorage_t, 1);
|
|
ppcDefineParamStr(dataName, 2);
|
|
|
|
if(dataName == nullptr)
|
|
{
|
|
if (storage->storageKind != 1)
|
|
{
|
|
osLib_returnFromFunction(hCPU, 0xC0203780);
|
|
return;
|
|
}
|
|
}
|
|
|
|
nsData->storage.accountId = storage->accountId;
|
|
nsData->storage.storageKind = storage->storageKind;
|
|
|
|
memcpy(nsData->storage.ukn08Array, storage->ukn08Array, 3);
|
|
memcpy(nsData->storage.storageName, storage->storageName, 8);
|
|
|
|
nsData->storage.titleId.u64 = storage->titleId.u64;
|
|
|
|
nsData->storage = *storage;
|
|
|
|
if (dataName != nullptr || storage->storageKind != 1)
|
|
strncpy(nsData->name, dataName, 0x20);
|
|
else
|
|
strncpy(nsData->name, "rawcontent.dat", 0x20);
|
|
nsData->name[0x1F] = '\0';
|
|
|
|
nsData->readIndex = 0;
|
|
|
|
cemuLog_logDebug(LogType::Force, "nnBossNsDataExport_initialize: {}", nsData->name);
|
|
|
|
osLib_returnFromFunction(hCPU, 0x200080);
|
|
}
|
|
|
|
std::string nnBossNsDataExport_GetPath(nsData_t* nsData)
|
|
{
|
|
uint32 accountId = nsData->storage.accountId;
|
|
if (accountId == 0)
|
|
accountId = iosuAct_getAccountIdOfCurrentAccount();
|
|
|
|
uint64 title_id = nsData->storage.titleId.u64;
|
|
if (title_id == 0)
|
|
title_id = CafeSystem::GetForegroundTitleId();
|
|
|
|
fs::path path = fmt::format(L"cemuBossStorage/{:08x}/{:08x}/user/{:08x}", (uint32)(title_id >> 32), (uint32)(title_id & 0xFFFFFFFF), accountId);
|
|
path /= nsData->storage.storageName;
|
|
path /= nsData->name;
|
|
return path.string();
|
|
}
|
|
|
|
void nnBossNsDataExport_DeleteRealFileWithHistory(PPCInterpreter_t* hCPU)
|
|
{
|
|
ppcDefineParamStructPtr(nsData, nsData_t, 0);
|
|
cemuLog_logDebug(LogType::Force, "nn_boss.NsData_DeleteRealFileWithHistory(...)");
|
|
|
|
if (nsData->storage.storageKind == nn::boss::kStorageKind_NBDL)
|
|
{
|
|
// todo
|
|
cemuLog_log(LogType::Force, "BOSS NBDL: Unsupported delete");
|
|
}
|
|
else
|
|
{
|
|
sint32 fscStatus = FSC_STATUS_OK;
|
|
std::string filePath = nnBossNsDataExport_GetPath(nsData).c_str();
|
|
fsc_remove((char*)filePath.c_str(), &fscStatus);
|
|
if (fscStatus != 0)
|
|
cemuLog_log(LogType::Force, "Unhandeled FSC status in BOSS DeleteRealFileWithHistory()");
|
|
}
|
|
osLib_returnFromFunction(hCPU, 0);
|
|
}
|
|
|
|
void nnBossNsDataExport_Exist(PPCInterpreter_t* hCPU)
|
|
{
|
|
cemuLog_logDebug(LogType::Force, "nn_boss.NsData_Exist(...)");
|
|
ppcDefineParamStructPtr(nsData, nsData_t, 0);
|
|
|
|
bool fileExists = false;
|
|
if(nsData->storage.storageKind == nn::boss::kStorageKind_NBDL)
|
|
{
|
|
// check if name is present in fad table
|
|
bossStorageFadEntry_t* fadTable = nnBossStorageFad_getTable(&nsData->storage);
|
|
if (fadTable)
|
|
{
|
|
fileExists = nnBossStorageFad_getIndexByName(fadTable, nsData->name) >= 0;
|
|
cemuLog_logDebug(LogType::Force, "\t({}) -> {}", nsData->name, fileExists);
|
|
free(fadTable);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sint32 fscStatus;
|
|
auto fscStorageFile = fsc_open((char*)nnBossNsDataExport_GetPath(nsData).c_str(), FSC_ACCESS_FLAG::OPEN_FILE, &fscStatus);
|
|
if (fscStorageFile != nullptr)
|
|
{
|
|
fileExists = true;
|
|
fsc_close(fscStorageFile);
|
|
}
|
|
}
|
|
|
|
osLib_returnFromFunction(hCPU, fileExists?1:0);
|
|
}
|
|
|
|
void nnBossNsDataExport_getSize(PPCInterpreter_t* hCPU)
|
|
{
|
|
ppcDefineParamStructPtr(nsData, nsData_t, 0);
|
|
|
|
FSCVirtualFile* fscStorageFile = nullptr;
|
|
if (nsData->storage.storageKind == nn::boss::kStorageKind_NBDL)
|
|
{
|
|
bossStorageFadEntry_t fadEntry;
|
|
if (nnBossStorageFad_getEntryByName(&nsData->storage, nsData->name, &fadEntry) == false)
|
|
{
|
|
cemuLog_log(LogType::Force, "BOSS storage cant find file {}", nsData->name);
|
|
osLib_returnFromFunction(hCPU, 0);
|
|
return;
|
|
}
|
|
// open file
|
|
fscStorageFile = nnBossStorageFile_open(&nsData->storage, fadEntry.fileNameId);
|
|
}
|
|
else
|
|
{
|
|
sint32 fscStatus;
|
|
fscStorageFile = fsc_open((char*)nnBossNsDataExport_GetPath(nsData).c_str(), FSC_ACCESS_FLAG::OPEN_FILE | FSC_ACCESS_FLAG::READ_PERMISSION, &fscStatus);
|
|
}
|
|
|
|
if (fscStorageFile == nullptr)
|
|
{
|
|
cemuLog_log(LogType::Force, "BOSS storage cant open file alias {}", nsData->name);
|
|
osLib_returnFromFunction(hCPU, 0);
|
|
return;
|
|
}
|
|
|
|
// get size
|
|
const sint32 fileSize = fsc_getFileSize(fscStorageFile);
|
|
// close file
|
|
fsc_close(fscStorageFile);
|
|
osLib_returnFromFunction64(hCPU, fileSize);
|
|
}
|
|
|
|
uint32 nnBossNsData_read(nsData_t* nsData, uint64* sizeOutBE, void* buffer, sint32 length)
|
|
{
|
|
FSCVirtualFile* fscStorageFile = nullptr;
|
|
if (nsData->storage.storageKind == nn::boss::kStorageKind_NBDL)
|
|
{
|
|
bossStorageFadEntry_t fadEntry;
|
|
if (nnBossStorageFad_getEntryByName(&nsData->storage, nsData->name, &fadEntry) == false)
|
|
{
|
|
cemuLog_log(LogType::Force, "BOSS storage cant find file {} for reading", nsData->name);
|
|
return 0x80000000; // todo - proper error code
|
|
}
|
|
// open file
|
|
fscStorageFile = nnBossStorageFile_open(&nsData->storage, fadEntry.fileNameId);
|
|
}
|
|
else
|
|
{
|
|
sint32 fscStatus;
|
|
fscStorageFile = fsc_open((char*)nnBossNsDataExport_GetPath(nsData).c_str(), FSC_ACCESS_FLAG::OPEN_FILE | FSC_ACCESS_FLAG::READ_PERMISSION, &fscStatus);
|
|
}
|
|
|
|
if (!fscStorageFile)
|
|
{
|
|
cemuLog_log(LogType::Force, "BOSS storage cant open file alias {} for reading", nsData->name);
|
|
return 0x80000000; // todo - proper error code
|
|
}
|
|
// get size
|
|
sint32 fileSize = fsc_getFileSize(fscStorageFile);
|
|
// verify read is within bounds
|
|
sint32 readEndOffset = (sint32)_swapEndianU64(nsData->readIndex) + length;
|
|
sint32 readBytes = length;
|
|
if (readEndOffset > fileSize)
|
|
{
|
|
readBytes = fileSize - (sint32)_swapEndianU64(nsData->readIndex);
|
|
cemu_assert_debug(readBytes != 0);
|
|
}
|
|
// read
|
|
fsc_setFileSeek(fscStorageFile, (uint32)_swapEndianU64(nsData->readIndex));
|
|
fsc_readFile(fscStorageFile, buffer, readBytes);
|
|
nsData->readIndex = _swapEndianU64((sint32)_swapEndianU64(nsData->readIndex) + readBytes);
|
|
|
|
// close file
|
|
fsc_close(fscStorageFile);
|
|
if (sizeOutBE)
|
|
*sizeOutBE = _swapEndianU64(readBytes);
|
|
return 0;
|
|
}
|
|
|
|
#define NSDATA_SEEK_MODE_BEGINNING (0)
|
|
|
|
uint32 nnBossNsData_seek(nsData_t* nsData, uint64 seek, uint32 mode)
|
|
{
|
|
FSCVirtualFile* fscStorageFile = nullptr;
|
|
if (nsData->storage.storageKind == nn::boss::kStorageKind_NBDL)
|
|
{
|
|
bossStorageFadEntry_t fadEntry;
|
|
if (nnBossStorageFad_getEntryByName(&nsData->storage, nsData->name, &fadEntry) == false)
|
|
{
|
|
cemuLog_log(LogType::Force, "BOSS storage cant find file {} for reading", nsData->name);
|
|
return 0x80000000; // todo - proper error code
|
|
}
|
|
// open file
|
|
fscStorageFile = nnBossStorageFile_open(&nsData->storage, fadEntry.fileNameId);
|
|
}
|
|
else
|
|
{
|
|
sint32 fscStatus;
|
|
fscStorageFile = fsc_open((char*)nnBossNsDataExport_GetPath(nsData).c_str(), FSC_ACCESS_FLAG::OPEN_FILE | FSC_ACCESS_FLAG::READ_PERMISSION, &fscStatus);
|
|
}
|
|
|
|
if (fscStorageFile == nullptr)
|
|
{
|
|
cemuLog_log(LogType::Force, "BOSS storage cant open file alias {} for reading", nsData->name);
|
|
return 0x80000000; // todo - proper error code
|
|
}
|
|
// get size
|
|
sint32 fileSize = fsc_getFileSize(fscStorageFile);
|
|
// handle seek
|
|
if (mode == NSDATA_SEEK_MODE_BEGINNING)
|
|
{
|
|
seek = std::min(seek, (uint64)fileSize);
|
|
nsData->readIndex = _swapEndianU64((uint64)seek);
|
|
}
|
|
else
|
|
{
|
|
cemu_assert_unimplemented();
|
|
}
|
|
fsc_close(fscStorageFile);
|
|
return 0;
|
|
}
|
|
|
|
void nnBossNsDataExport_read(PPCInterpreter_t* hCPU)
|
|
{
|
|
ppcDefineParamStructPtr(nsData, nsData_t, 0);
|
|
ppcDefineParamStr(buffer, 1);
|
|
ppcDefineParamS32(length, 2);
|
|
|
|
cemuLog_logDebug(LogType::Force, "nsData read (filename {})", nsData->name);
|
|
|
|
uint32 r = nnBossNsData_read(nsData, nullptr, buffer, length);
|
|
|
|
osLib_returnFromFunction(hCPU, r);
|
|
}
|
|
|
|
void nnBossNsDataExport_readWithSizeOut(PPCInterpreter_t* hCPU)
|
|
{
|
|
ppcDefineParamStructPtr(nsData, nsData_t, 0);
|
|
ppcDefineParamTypePtr(sizeOut, uint64, 1);
|
|
ppcDefineParamStr(buffer, 2);
|
|
ppcDefineParamS32(length, 3);
|
|
|
|
uint32 r = nnBossNsData_read(nsData, sizeOut, buffer, length);
|
|
cemuLog_logDebug(LogType::Force, "nsData readWithSizeOut (filename {} length 0x{:x}) Result: {} Sizeout: {:x}", nsData->name, length, r, _swapEndianU64(*sizeOut));
|
|
|
|
osLib_returnFromFunction(hCPU, r);
|
|
}
|
|
|
|
void nnBossNsDataExport_seek(PPCInterpreter_t* hCPU)
|
|
{
|
|
ppcDefineParamStructPtr(nsData, nsData_t, 0);
|
|
ppcDefineParamU64(seekPos, 2);
|
|
ppcDefineParamU32(mode, 4);
|
|
|
|
uint32 r = nnBossNsData_seek(nsData, seekPos, mode);
|
|
|
|
cemuLog_logDebug(LogType::Force, "nsData seek (filename {} seek 0x{:x}) Result: {}", nsData->name, (uint32)seekPos, r);
|
|
|
|
osLib_returnFromFunction(hCPU, r);
|
|
}
|
|
|
|
void nnBoss_load()
|
|
{
|
|
OSInitMutexEx(&nn::boss::g_mutex, nullptr);
|
|
|
|
osLib_addFunction("nn_boss", "Initialize__Q2_2nn4bossFv", nn::boss::export_Initialize);
|
|
osLib_addFunction("nn_boss", "GetBossState__Q2_2nn4bossFv", nn::boss::export_GetBossState);
|
|
|
|
// task
|
|
osLib_addFunction("nn_boss", "__ct__Q3_2nn4boss4TaskFv", nn::boss::Task::export_ctor);
|
|
osLib_addFunction("nn_boss", "Run__Q3_2nn4boss4TaskFb", nn::boss::Task::export_Run);
|
|
osLib_addFunction("nn_boss", "Wait__Q3_2nn4boss4TaskFUiQ3_2nn4boss13TaskWaitState", nn::boss::Task::export_Wait);
|
|
osLib_addFunction("nn_boss", "GetTurnState__Q3_2nn4boss4TaskCFPUi", nn::boss::Task::export_GetTurnState);
|
|
osLib_addFunction("nn_boss", "GetHttpStatusCode__Q3_2nn4boss4TaskCFPUi", nn::boss::Task::export_GetHttpStatusCode);
|
|
osLib_addFunction("nn_boss", "GetContentLength__Q3_2nn4boss4TaskCFPUi", nn::boss::Task::export_GetContentLength);
|
|
osLib_addFunction("nn_boss", "GetProcessedLength__Q3_2nn4boss4TaskCFPUi", nn::boss::Task::export_GetProcessedLength);
|
|
osLib_addFunction("nn_boss", "Register__Q3_2nn4boss4TaskFRQ3_2nn4boss11TaskSetting", nn::boss::Task::export_Register);
|
|
osLib_addFunction("nn_boss", "Unregister__Q3_2nn4boss4TaskFv", nn::boss::Task::export_Unregister);
|
|
osLib_addFunction("nn_boss", "Initialize__Q3_2nn4boss4TaskFPCc", nn::boss::Task::export_Initialize1);
|
|
osLib_addFunction("nn_boss", "Initialize__Q3_2nn4boss4TaskFUcPCc", nn::boss::Task::export_Initialize2);
|
|
osLib_addFunction("nn_boss", "Initialize__Q3_2nn4boss4TaskFPCcUi", nn::boss::Task::export_Initialize3);
|
|
osLib_addFunction("nn_boss", "IsRegistered__Q3_2nn4boss4TaskCFv", nn::boss::Task::export_IsRegistered);
|
|
osLib_addFunction("nn_boss", "RegisterForImmediateRun__Q3_2nn4boss4TaskFRCQ3_2nn4boss11TaskSetting", nn::boss::Task::export_RegisterForImmediateRun);
|
|
osLib_addFunction("nn_boss", "StartScheduling__Q3_2nn4boss4TaskFb", nn::boss::Task::export_StartScheduling);
|
|
osLib_addFunction("nn_boss", "StopScheduling__Q3_2nn4boss4TaskFv", nn::boss::Task::export_StopScheduling);
|
|
|
|
// Nbdl task setting
|
|
osLib_addFunction("nn_boss", "__ct__Q3_2nn4boss15NbdlTaskSettingFv", nn::boss::NbdlTaskSetting::export_ctor);
|
|
osLib_addFunction("nn_boss", "Initialize__Q3_2nn4boss15NbdlTaskSettingFPCcLT1", nn::boss::NbdlTaskSetting::export_Initialize);
|
|
//osLib_addFunction("nn_boss", "SetFileName__Q3_2nn4boss15NbdlTaskSettingFPCc", nn::boss::NbdlTaskSetting::export_SetFileName);
|
|
cafeExportRegisterFunc(nn::boss::NbdlTaskSetting::SetFileName, "nn_boss", "SetFileName__Q3_2nn4boss15NbdlTaskSettingFPCc", LogType::Placeholder);
|
|
|
|
// play task setting
|
|
osLib_addFunction("nn_boss", "__ct__Q3_2nn4boss17PlayReportSettingFv", nn::boss::PlayReportSetting::export_ctor);
|
|
osLib_addFunction("nn_boss", "Set__Q3_2nn4boss17PlayReportSettingFPCcUi", nn::boss::PlayReportSetting::export_Set);
|
|
//osLib_addFunction("nn_boss", "Set__Q3_2nn4boss17PlayReportSettingFUiT1", nn::boss::PlayReportSetting::export_Set);
|
|
osLib_addFunction("nn_boss", "Initialize__Q3_2nn4boss17PlayReportSettingFPvUi", nn::boss::PlayReportSetting::export_Initialize);
|
|
|
|
cafeExportRegisterFunc(nn::boss::RawDlTaskSetting::ctor, "nn_boss", "__ct__Q3_2nn4boss16RawDlTaskSettingFv", LogType::Placeholder);
|
|
cafeExportRegisterFunc(nn::boss::RawDlTaskSetting::Initialize, "nn_boss", "Initialize__Q3_2nn4boss16RawDlTaskSettingFPCcbT2N21", LogType::Placeholder);
|
|
|
|
cafeExportRegisterFunc(nn::boss::NetTaskSetting::SetServiceToken, "nn_boss", "SetServiceToken__Q3_2nn4boss14NetTaskSettingFPCUc", LogType::Placeholder);
|
|
cafeExportRegisterFunc(nn::boss::NetTaskSetting::AddInternalCaCert, "nn_boss", "AddInternalCaCert__Q3_2nn4boss14NetTaskSettingFSc", LogType::Placeholder);
|
|
cafeExportRegisterFunc(nn::boss::NetTaskSetting::SetInternalClientCert, "nn_boss", "SetInternalClientCert__Q3_2nn4boss14NetTaskSettingFSc", LogType::Placeholder);
|
|
|
|
// Title
|
|
cafeExportRegisterFunc(nn::boss::Title::ctor, "nn_boss", "__ct__Q3_2nn4boss5TitleFv", LogType::Placeholder);
|
|
// cafeExportMakeWrapper<nn::boss::Title::SetNewArrivalFlagOff>("nn_boss", "SetNewArrivalFlagOff__Q3_2nn4boss5TitleFv"); SMM bookmarks
|
|
|
|
// TitleId
|
|
cafeExportRegisterFunc(nn::boss::TitleId::ctor1, "nn_boss", "__ct__Q3_2nn4boss7TitleIDFv", LogType::Placeholder);
|
|
cafeExportRegisterFunc(nn::boss::TitleId::ctor2, "nn_boss", "__ct__Q3_2nn4boss7TitleIDFUL", LogType::Placeholder);
|
|
cafeExportRegisterFunc(nn::boss::TitleId::cctor, "nn_boss", "__ct__Q3_2nn4boss7TitleIDFRCQ3_2nn4boss7TitleID", LogType::Placeholder);
|
|
cafeExportRegisterFunc(nn::boss::TitleId::operator_ne, "nn_boss", "__ne__Q3_2nn4boss7TitleIDCFRCQ3_2nn4boss7TitleID", LogType::Placeholder);
|
|
|
|
// DataName
|
|
osLib_addFunction("nn_boss", "__ct__Q3_2nn4boss8DataNameFv", nnBossDataNameExport_ct);
|
|
osLib_addFunction("nn_boss", "__opPCc__Q3_2nn4boss8DataNameCFv", nnBossDataNameExport_opPCc);
|
|
|
|
// DirectoryName
|
|
cafeExportRegisterFunc(nn::boss::DirectoryName::ctor, "nn_boss", "__ct__Q3_2nn4boss13DirectoryNameFv", LogType::Placeholder);
|
|
cafeExportRegisterFunc(nn::boss::DirectoryName::operator_const_char, "nn_boss", "__opPCc__Q3_2nn4boss13DirectoryNameCFv", LogType::Placeholder);
|
|
|
|
// Account
|
|
cafeExportRegisterFunc(nn::boss::Account::ctor, "nn_boss", "__ct__Q3_2nn4boss7AccountFUi", LogType::Placeholder);
|
|
|
|
|
|
// storage
|
|
osLib_addFunction("nn_boss", "__ct__Q3_2nn4boss7StorageFv", nnBossStorageExport_ct);
|
|
//osLib_addFunction("nn_boss", "Initialize__Q3_2nn4boss7StorageFPCcQ3_2nn4boss11StorageKind", nnBossStorageExport_initialize);
|
|
osLib_addFunction("nn_boss", "Exist__Q3_2nn4boss7StorageCFv", nnBossStorageExport_exist);
|
|
osLib_addFunction("nn_boss", "GetDataList__Q3_2nn4boss7StorageCFPQ3_2nn4boss8DataNameUiPUiT2", nnBossStorageExport_getDataList);
|
|
osLib_addFunction("nn_boss", "GetDataList__Q3_2nn4boss7StorageCFPQ3_2nn4boss8DataNameUiPUiT2", nnBossStorageExport_getDataList);
|
|
cafeExportRegisterFunc(nn::boss::Storage::Initialize, "nn_boss", "Initialize__Q3_2nn4boss7StorageFPCcUiQ3_2nn4boss11StorageKind", LogType::Placeholder);
|
|
cafeExportRegisterFunc(nn::boss::Storage::Initialize2, "nn_boss", "Initialize__Q3_2nn4boss7StorageFPCcQ3_2nn4boss11StorageKind", LogType::Placeholder);
|
|
|
|
// AlmightyStorage
|
|
cafeExportRegisterFunc(nn::boss::AlmightyStorage::ctor, "nn_boss", "__ct__Q3_2nn4boss15AlmightyStorageFv", LogType::Placeholder );
|
|
cafeExportRegisterFunc(nn::boss::AlmightyStorage::Initialize, "nn_boss", "Initialize__Q3_2nn4boss15AlmightyStorageFQ3_2nn4boss7TitleIDPCcUiQ3_2nn4boss11StorageKind", LogType::Placeholder );
|
|
|
|
// AlmightyTask
|
|
cafeExportRegisterFunc(nn::boss::AlmightyTask::ctor, "nn_boss", "__ct__Q3_2nn4boss12AlmightyTaskFv", LogType::Placeholder);
|
|
cafeExportRegisterFunc(nn::boss::AlmightyTask::Initialize, "nn_boss", "Initialize__Q3_2nn4boss12AlmightyTaskFQ3_2nn4boss7TitleIDPCcUi", LogType::Placeholder);
|
|
// cafeExportRegisterFunc(nn::boss::AlmightyTask::dtor, "nn_boss", "__dt__Q3_2nn4boss12AlmightyTaskFv", LogType::Placeholder);
|
|
|
|
// NsData
|
|
osLib_addFunction("nn_boss", "__ct__Q3_2nn4boss6NsDataFv", nnBossNsDataExport_ct);
|
|
osLib_addFunction("nn_boss", "Initialize__Q3_2nn4boss6NsDataFRCQ3_2nn4boss7StoragePCc", nnBossNsDataExport_initialize);
|
|
osLib_addFunction("nn_boss", "DeleteRealFileWithHistory__Q3_2nn4boss6NsDataFv", nnBossNsDataExport_DeleteRealFileWithHistory);
|
|
osLib_addFunction("nn_boss", "Exist__Q3_2nn4boss6NsDataCFv", nnBossNsDataExport_Exist);
|
|
osLib_addFunction("nn_boss", "GetSize__Q3_2nn4boss6NsDataCFv", nnBossNsDataExport_getSize);
|
|
osLib_addFunction("nn_boss", "Read__Q3_2nn4boss6NsDataFPvUi", nnBossNsDataExport_read);
|
|
osLib_addFunction("nn_boss", "Read__Q3_2nn4boss6NsDataFPLPvUi", nnBossNsDataExport_readWithSizeOut);
|
|
osLib_addFunction("nn_boss", "Seek__Q3_2nn4boss6NsDataFLQ3_2nn4boss12PositionBase", nnBossNsDataExport_seek);
|
|
|
|
}
|