mirror of
https://github.com/DarkStore-3DS/Project_CTR.git
synced 2026-07-03 08:49:03 +00:00
jakcron
1304 lines
45 KiB
C
1304 lines
45 KiB
C
#include "lib.h"
|
|
#include "ncch_build.h"
|
|
#include "exheader_build.h"
|
|
#include "accessdesc.h"
|
|
#include "titleid.h"
|
|
|
|
const char *DEFAULT_EXHEADER_NAME = "CtrApp";
|
|
|
|
/* Prototypes */
|
|
void free_ExHeaderSettings(exheader_settings *exhdrset);
|
|
int get_ExHeaderSettingsFromNcchset(exheader_settings *exhdrset, ncch_settings *ncchset);
|
|
int get_ExHeaderSettingsFromRsf(exheader_settings *exhdrset);
|
|
|
|
int get_ExHeaderCodeSetInfo(exhdr_CodeSetInfo *CodeSetInfo, rsf_settings *rsf);
|
|
int get_ExHeaderDependencyList(u8 *depList, rsf_settings *rsf);
|
|
int get_ExHeaderSystemInfo(exhdr_SystemInfo *systemInfo, rsf_settings *rsf);
|
|
int get_ExHeaderARM11SystemLocalInfo(exhdr_ARM11SystemLocalCapabilities *arm11, rsf_settings *rsf);
|
|
int get_ExHeaderARM11SystemLocalInfoLimited(exhdr_ARM11SystemLocalCapabilities *arm11, rsf_settings *rsf);
|
|
int SetARM11SystemLocalInfoFlags(exhdr_ARM11SystemLocalCapabilities *arm11, rsf_settings *rsf);
|
|
int GetAppType(rsf_settings *rsf);
|
|
int SetARM11ResLimitDesc(exhdr_ARM11SystemLocalCapabilities *arm11, rsf_settings *rsf);
|
|
int SetARM11StorageInfo(exhdr_ARM11SystemLocalCapabilities *arm11, rsf_settings *rsf);
|
|
void SetARM11StorageInfoSystemSaveDataId(exhdr_ARM11SystemLocalCapabilities *arm11, rsf_settings *rsf);
|
|
int SetARM11StorageInfoFsAccessInfo(exhdr_ARM11SystemLocalCapabilities *arm11, rsf_settings *rsf);
|
|
void SetARM11StorageInfoExtSaveDataId(exhdr_ARM11SystemLocalCapabilities *arm11, rsf_settings *rsf);
|
|
void SetARM11StorageInfoOtherUserSaveData(exhdr_ARM11SystemLocalCapabilities *arm11, rsf_settings *rsf);
|
|
bool CheckCondiditionsForNewAccessibleSaveDataIds(rsf_settings *rsf);
|
|
void SetARM11StorageInfoAccessibleSaveDataIds(exhdr_ARM11SystemLocalCapabilities *arm11, rsf_settings *rsf);
|
|
int SetARM11ServiceAccessControl(exhdr_ARM11SystemLocalCapabilities *arm11, rsf_settings *rsf);
|
|
int get_ExHeaderARM11KernelInfo(exhdr_ARM11KernelCapabilities *arm11, rsf_settings *rsf);
|
|
int SetARM11KernelDescSysCallControl(ARM11KernelCapabilityDescriptor *desc, rsf_settings *rsf);
|
|
int GetARM11SysCalls(ARM11KernelCapabilityDescriptor *desc, rsf_settings *rsf);
|
|
void EnableSystemCall(ARM11KernelCapabilityDescriptor *desc, int sysCall);
|
|
void DisableSystemCall(ARM11KernelCapabilityDescriptor *desc, int SysCall);
|
|
int SetARM11KernelDescInteruptNumList(ARM11KernelCapabilityDescriptor *desc, rsf_settings *rsf);
|
|
int GetARM11Interupts(ARM11KernelCapabilityDescriptor *desc, rsf_settings *rsf);
|
|
void EnableInterupt(ARM11KernelCapabilityDescriptor *desc, int Interrupt, int i);
|
|
int SetARM11KernelDescAddressMapping(ARM11KernelCapabilityDescriptor *desc, rsf_settings *rsf);
|
|
int GetARM11IOMappings(ARM11KernelCapabilityDescriptor *desc, rsf_settings *rsf);
|
|
int GetARM11StaticMappings(ARM11KernelCapabilityDescriptor *desc, rsf_settings *rsf);
|
|
bool IsEndAddress(u32 Address);
|
|
bool IsStartAddress(u32 Address);
|
|
u32 GetIOMappingDesc(u32 address);
|
|
u32 GetStaticMappingDesc(u32 address, bool IsReadOnly);
|
|
u32 GetMappingDesc(u32 address, u32 prefixVal, s32 numPrefixBits, bool IsRO);
|
|
int SetARM11KernelDescOtherCapabilities(ARM11KernelCapabilityDescriptor *desc, rsf_settings *rsf);
|
|
int SetARM11KernelDescHandleTableSize(ARM11KernelCapabilityDescriptor *desc, rsf_settings *rsf);
|
|
int SetARM11KernelDescReleaseKernelVersion(ARM11KernelCapabilityDescriptor *desc, rsf_settings *rsf);
|
|
void SetARM11KernelDescValue(ARM11KernelCapabilityDescriptor *desc, u16 index, u32 value);
|
|
void SetARM11KernelDescBitmask(ARM11KernelCapabilityDescriptor *desc, u32 bitmask);
|
|
void AllocateARM11KernelDescMemory(ARM11KernelCapabilityDescriptor *desc, u16 num);
|
|
u32 GetDescPrefixMask(int numPrefixBits);
|
|
u32 GetDescPrefixBits(int numPrefixBits, u32 prefixVal);
|
|
int get_ExHeaderARM9AccessControlInfo(exhdr_ARM9AccessControlInfo *arm9, rsf_settings *rsf);
|
|
|
|
/* ExHeader Signature Functions */
|
|
int SignAccessDesc(access_descriptor *acexDesc, keys_struct *keys)
|
|
{
|
|
u8 *data = (u8*) &acexDesc->ncchRsaPubKey;
|
|
u8 *sign = (u8*) &acexDesc->signature;
|
|
return RsaSignVerify(data,0x300,sign,keys->rsa.acexPub,keys->rsa.acexPvt,RSA_2048_SHA256,CTR_RSA_SIGN);
|
|
}
|
|
|
|
int CheckAccessDescSignature(access_descriptor *acexDesc, keys_struct *keys)
|
|
{
|
|
u8 *data = (u8*) &acexDesc->ncchRsaPubKey;
|
|
u8 *sign = (u8*) &acexDesc->signature;
|
|
return RsaSignVerify(data,0x300,sign,keys->rsa.acexPub,NULL,RSA_2048_SHA256,CTR_RSA_VERIFY);
|
|
}
|
|
|
|
/* ExHeader Build Functions */
|
|
int BuildExHeader(ncch_settings *ncchset)
|
|
{
|
|
int result = 0;
|
|
|
|
if(ncchset->options.IsCfa)
|
|
return 0;
|
|
|
|
exheader_settings *exhdrset = calloc(1,sizeof(exheader_settings));
|
|
if(!exhdrset) {
|
|
fprintf(stderr,"[EXHEADER ERROR] Not enough memory\n");
|
|
return MEM_ERROR;
|
|
}
|
|
|
|
// Get Settings
|
|
result = get_ExHeaderSettingsFromNcchset(exhdrset,ncchset);
|
|
if(result) goto finish;
|
|
|
|
result = get_ExHeaderSettingsFromRsf(exhdrset);
|
|
if(result) goto finish;
|
|
|
|
result = set_AccessDesc(exhdrset);
|
|
if(result) goto finish;
|
|
|
|
finish:
|
|
if(result) fprintf(stderr,"[EXHEADER ERROR] Failed to create ExHeader\n");
|
|
free_ExHeaderSettings(exhdrset);
|
|
return result;
|
|
}
|
|
|
|
void free_ExHeaderSettings(exheader_settings *exhdrset)
|
|
{
|
|
free(exhdrset);
|
|
}
|
|
|
|
int get_ExHeaderSettingsFromNcchset(exheader_settings *exhdrset, ncch_settings *ncchset)
|
|
{
|
|
/* Transfer settings */
|
|
exhdrset->keys = ncchset->keys;
|
|
exhdrset->rsf = ncchset->rsfSet;
|
|
exhdrset->useAccessDescPreset = ncchset->keys->accessDescSign.presetType != desc_preset_NONE;
|
|
|
|
/* Creating Output Buffer */
|
|
ncchset->sections.exhdr.size = sizeof(extended_hdr);
|
|
ncchset->sections.exhdr.buffer = calloc(1,ncchset->sections.exhdr.size);
|
|
if(!ncchset->sections.exhdr.buffer) {
|
|
fprintf(stderr,"[EXHEADER ERROR] Not enough memory\n");
|
|
return MEM_ERROR;
|
|
}
|
|
|
|
ncchset->sections.acexDesc.size = sizeof(access_descriptor);
|
|
ncchset->sections.acexDesc.buffer = calloc(1,ncchset->sections.acexDesc.size);
|
|
if(!ncchset->sections.acexDesc.buffer) {
|
|
fprintf(stderr,"[EXHEADER ERROR] Not enough memory\n");
|
|
return MEM_ERROR;
|
|
}
|
|
|
|
/* Create ExHeader Struct for output */
|
|
exhdrset->exHdr = (extended_hdr*)ncchset->sections.exhdr.buffer;
|
|
exhdrset->acexDesc = (access_descriptor*)ncchset->sections.acexDesc.buffer;
|
|
|
|
/* Data */
|
|
u32_to_u8(exhdrset->exHdr->codeSetInfo.data.address,ncchset->codeDetails.rwAddress,LE);
|
|
u32_to_u8(exhdrset->exHdr->codeSetInfo.data.codeSize,ncchset->codeDetails.rwSize,LE);
|
|
u32_to_u8(exhdrset->exHdr->codeSetInfo.data.numMaxPages,ncchset->codeDetails.rwMaxPages,LE);
|
|
/* RO */
|
|
u32_to_u8(exhdrset->exHdr->codeSetInfo.rodata.address,ncchset->codeDetails.roAddress,LE);
|
|
u32_to_u8(exhdrset->exHdr->codeSetInfo.rodata.codeSize,ncchset->codeDetails.roSize,LE);
|
|
u32_to_u8(exhdrset->exHdr->codeSetInfo.rodata.numMaxPages,ncchset->codeDetails.roMaxPages,LE);
|
|
/* Text */
|
|
u32_to_u8(exhdrset->exHdr->codeSetInfo.text.address,ncchset->codeDetails.textAddress,LE);
|
|
u32_to_u8(exhdrset->exHdr->codeSetInfo.text.codeSize,ncchset->codeDetails.textSize,LE);
|
|
u32_to_u8(exhdrset->exHdr->codeSetInfo.text.numMaxPages,ncchset->codeDetails.textMaxPages,LE);
|
|
/* BSS Size */
|
|
u32_to_u8(exhdrset->exHdr->codeSetInfo.bssSize, ncchset->codeDetails.bssSize, LE);
|
|
/* Stack Size */
|
|
u32_to_u8(exhdrset->exHdr->codeSetInfo.stackSize, ncchset->codeDetails.stackSize, LE);
|
|
|
|
/* Set Simple Flags */
|
|
if(ncchset->options.CompressCode)
|
|
exhdrset->exHdr->codeSetInfo.compressExeFs0 = true;
|
|
if (ncchset->options.UseOnSD)
|
|
exhdrset->exHdr->codeSetInfo.useOnSd = true;
|
|
if(!ncchset->options.UseRomFS)
|
|
exhdrset->exHdr->arm11SystemLocalCapabilities.storageInfo.otherAttributes |= attribute_NOT_USE_ROMFS;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int get_ExHeaderSettingsFromRsf(exheader_settings *exhdrset)
|
|
{
|
|
int result = 0;
|
|
if(!exhdrset->useAccessDescPreset){
|
|
if((result = get_ExHeaderCodeSetInfo(&exhdrset->exHdr->codeSetInfo, exhdrset->rsf)))
|
|
goto finish;
|
|
if((result = get_ExHeaderDependencyList((u8*)exhdrset->exHdr->dependencyList, exhdrset->rsf)))
|
|
goto finish;
|
|
if((result = get_ExHeaderSystemInfo(&exhdrset->exHdr->systemInfo, exhdrset->rsf)))
|
|
goto finish;
|
|
if((result = get_ExHeaderARM11SystemLocalInfo(&exhdrset->exHdr->arm11SystemLocalCapabilities, exhdrset->rsf)))
|
|
goto finish;
|
|
if((result = get_ExHeaderARM11KernelInfo(&exhdrset->exHdr->arm11KernelCapabilities, exhdrset->rsf)))
|
|
goto finish;
|
|
if((result = get_ExHeaderARM9AccessControlInfo(&exhdrset->exHdr->arm9AccessControlInfo, exhdrset->rsf)))
|
|
goto finish;
|
|
}
|
|
else{
|
|
if((result = get_ExHeaderCodeSetInfo(&exhdrset->exHdr->codeSetInfo, exhdrset->rsf)))
|
|
goto finish;
|
|
if((result = get_ExHeaderSystemInfo(&exhdrset->exHdr->systemInfo, exhdrset->rsf)))
|
|
goto finish;
|
|
if((result = get_ExHeaderARM11SystemLocalInfoLimited(&exhdrset->exHdr->arm11SystemLocalCapabilities, exhdrset->rsf)))
|
|
goto finish;
|
|
if((result = get_ExHeaderARM9AccessControlInfo(&exhdrset->exHdr->arm9AccessControlInfo, exhdrset->rsf)))
|
|
goto finish;
|
|
}
|
|
|
|
finish:
|
|
return result;
|
|
}
|
|
|
|
int get_ExHeaderCodeSetInfo(exhdr_CodeSetInfo *CodeSetInfo, rsf_settings *rsf)
|
|
{
|
|
/* Name */
|
|
if (rsf->BasicInfo.Title)
|
|
strncpy((char*)CodeSetInfo->name, rsf->BasicInfo.Title, 8);
|
|
else
|
|
strncpy((char*)CodeSetInfo->name, DEFAULT_EXHEADER_NAME, 8);
|
|
|
|
/* Remaster Version */
|
|
if(rsf->SystemControlInfo.RemasterVersion)
|
|
u16_to_u8(CodeSetInfo->remasterVersion, strtol(rsf->SystemControlInfo.RemasterVersion,NULL,0), LE);
|
|
else
|
|
u16_to_u8(CodeSetInfo->remasterVersion, 0, LE);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int get_ExHeaderDependencyList(u8 *depList, rsf_settings *rsf)
|
|
{
|
|
if(rsf->SystemControlInfo.DependencyNum > 0x30){
|
|
fprintf(stderr,"[EXHEADER ERROR] Too Many Dependency IDs\n");
|
|
return EXHDR_BAD_RSF_OPT;
|
|
}
|
|
for(int i = 0; i < rsf->SystemControlInfo.DependencyNum; i++){
|
|
u8 *pos = (depList + 0x8*i);
|
|
u64_to_u8(pos, strtoull(rsf->SystemControlInfo.Dependency[i],NULL,0), LE);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int get_ExHeaderSystemInfo(exhdr_SystemInfo *systemInfo, rsf_settings *rsf)
|
|
{
|
|
/* SaveDataSize */
|
|
if(rsf->SystemControlInfo.SaveDataSize){
|
|
u64 saveSize = 0;
|
|
if(GetSaveDataSizeFromString(&saveSize,rsf->SystemControlInfo.SaveDataSize,"EXHEADER"))
|
|
return EXHDR_BAD_RSF_OPT;
|
|
u64_to_u8(systemInfo->savedataSize, saveSize, LE);
|
|
}
|
|
else
|
|
u64_to_u8(systemInfo->savedataSize,0,LE);
|
|
|
|
/* Jump Id */
|
|
if(rsf->SystemControlInfo.JumpId)
|
|
u64_to_u8(systemInfo->jumpId, strtoull(rsf->SystemControlInfo.JumpId,NULL,0), LE);
|
|
|
|
else{
|
|
u64 jumpId = 0;
|
|
if(GetProgramID(&jumpId,rsf,false))
|
|
return EXHDR_BAD_RSF_OPT;
|
|
u64_to_u8(systemInfo->jumpId,jumpId,LE);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int get_ExHeaderARM11SystemLocalInfo(exhdr_ARM11SystemLocalCapabilities *arm11, rsf_settings *rsf)
|
|
{
|
|
/* Program Id */
|
|
u64 programId = 0;
|
|
if(GetProgramID(&programId,rsf,true))
|
|
return EXHDR_BAD_RSF_OPT;
|
|
u64_to_u8(arm11->programId,programId,LE);
|
|
|
|
/* Flags */
|
|
if(SetARM11SystemLocalInfoFlags(arm11, rsf))
|
|
return EXHDR_BAD_RSF_OPT;
|
|
|
|
/* Resource Limit Descriptors */
|
|
if(SetARM11ResLimitDesc(arm11, rsf))
|
|
return EXHDR_BAD_RSF_OPT;
|
|
|
|
/* Storage Info */
|
|
if(SetARM11StorageInfo(arm11, rsf))
|
|
return EXHDR_BAD_RSF_OPT;
|
|
|
|
/* Service Access Control */
|
|
if(SetARM11ServiceAccessControl(arm11, rsf))
|
|
return EXHDR_BAD_RSF_OPT;
|
|
|
|
/* Resource Limit Category */
|
|
if(rsf->AccessControlInfo.ResourceLimitCategory){
|
|
if(strcasecmp(rsf->AccessControlInfo.ResourceLimitCategory,"application") == 0) arm11->resourceLimitCategory = resrc_limit_APPLICATION;
|
|
else if(strcasecmp(rsf->AccessControlInfo.ResourceLimitCategory,"sysapplet") == 0) arm11->resourceLimitCategory = resrc_limit_SYS_APPLET;
|
|
else if(strcasecmp(rsf->AccessControlInfo.ResourceLimitCategory,"libapplet") == 0) arm11->resourceLimitCategory = resrc_limit_LIB_APPLET;
|
|
else if(strcasecmp(rsf->AccessControlInfo.ResourceLimitCategory,"other") == 0) arm11->resourceLimitCategory = resrc_limit_OTHER;
|
|
}
|
|
|
|
/* Finish */
|
|
return 0;
|
|
}
|
|
|
|
int get_ExHeaderARM11SystemLocalInfoLimited(exhdr_ARM11SystemLocalCapabilities *arm11, rsf_settings *rsf)
|
|
{
|
|
/* Program Id */
|
|
u64 programId = 0;
|
|
if(GetProgramID(&programId,rsf,true))
|
|
return EXHDR_BAD_RSF_OPT;
|
|
u64_to_u8(arm11->programId,programId,LE);
|
|
|
|
/* Storage Info */
|
|
if(SetARM11StorageInfo(arm11, rsf))
|
|
return EXHDR_BAD_RSF_OPT;
|
|
|
|
/* Finish */
|
|
return 0;
|
|
}
|
|
|
|
int SetARM11SystemLocalInfoFlags(exhdr_ARM11SystemLocalCapabilities *arm11, rsf_settings *rsf)
|
|
{
|
|
/* Core Version */
|
|
if(rsf->AccessControlInfo.CoreVersion)
|
|
u32_to_u8(arm11->coreVersion,strtoul(rsf->AccessControlInfo.CoreVersion,NULL,0),LE);
|
|
else{
|
|
ErrorParamNotFound("AccessControlInfo/CoreVersion");
|
|
return EXHDR_BAD_RSF_OPT;
|
|
}
|
|
|
|
/* Defaults */
|
|
arm11->enableL2Cache = false;
|
|
arm11->cpuSpeed = cpuspeed_268MHz;
|
|
arm11->systemModeExt = sysmode_ext_LEGACY;
|
|
arm11->affinityMask = 0;
|
|
arm11->idealProcessor = 0;
|
|
arm11->systemMode = sysmode_64MB;
|
|
|
|
/* flag[0] */
|
|
arm11->enableL2Cache |= rsf->AccessControlInfo.EnableL2Cache;
|
|
|
|
if (rsf->AccessControlInfo.CpuSpeed) {
|
|
if(strcasecmp(rsf->AccessControlInfo.CpuSpeed, "268mhz") == 0)
|
|
arm11->cpuSpeed |= cpuspeed_268MHz;
|
|
else if(strcasecmp(rsf->AccessControlInfo.CpuSpeed, "804mhz") == 0)
|
|
arm11->cpuSpeed |= cpuspeed_804MHz;
|
|
else {
|
|
fprintf(stderr, "[EXHEADER ERROR] Invalid cpu speed: 0x%s\n", rsf->AccessControlInfo.CpuSpeed);
|
|
return EXHDR_BAD_RSF_OPT;
|
|
}
|
|
}
|
|
|
|
/* flag[1] (SystemModeExt) */
|
|
if (rsf->AccessControlInfo.SystemModeExt) {
|
|
if (strcasecmp(rsf->AccessControlInfo.SystemModeExt, "Legacy") == 0)
|
|
arm11->systemModeExt = sysmode_ext_LEGACY;
|
|
else if (strcasecmp(rsf->AccessControlInfo.SystemModeExt, "124MB") == 0)
|
|
arm11->systemModeExt = sysmode_ext_124MB;
|
|
else if (strcasecmp(rsf->AccessControlInfo.SystemModeExt, "178MB") == 0)
|
|
arm11->systemModeExt = sysmode_ext_178MB;
|
|
|
|
else {
|
|
fprintf(stderr, "[EXHEADER ERROR] Unexpected SystemModeExt: %s\n", rsf->AccessControlInfo.SystemModeExt);
|
|
return EXHDR_BAD_RSF_OPT;
|
|
}
|
|
}
|
|
|
|
/* flag[2] */
|
|
if(rsf->AccessControlInfo.AffinityMask){
|
|
arm11->affinityMask = strtol(rsf->AccessControlInfo.AffinityMask,NULL,0);
|
|
if(arm11->affinityMask > 1){
|
|
fprintf(stderr,"[EXHEADER ERROR] Unexpected AffinityMask: %d. Expected range: 0x0 - 0x1\n", arm11->affinityMask);
|
|
return EXHDR_BAD_RSF_OPT;
|
|
}
|
|
}
|
|
if(rsf->AccessControlInfo.IdealProcessor){
|
|
arm11->idealProcessor = strtol(rsf->AccessControlInfo.IdealProcessor,NULL,0);
|
|
if(arm11->idealProcessor > 1){
|
|
fprintf(stderr,"[EXHEADER ERROR] Unexpected IdealProcessor: %d. Expected range: 0x0 - 0x1\n", arm11->idealProcessor);
|
|
return EXHDR_BAD_RSF_OPT;
|
|
}
|
|
}
|
|
if(rsf->AccessControlInfo.SystemMode){
|
|
if (strcasecmp(rsf->AccessControlInfo.SystemMode, "64MB") == 0 || strcasecmp(rsf->AccessControlInfo.SystemMode, "prod") == 0)
|
|
arm11->systemMode = sysmode_64MB;
|
|
//else if (strcasecmp(rsf->AccessControlInfo.SystemMode, "UNK") == 0 || strcasecmp(rsf->AccessControlInfo.SystemMode, "null") == 0)
|
|
// arm11->systemMode = sysmode_UNK;
|
|
else if (strcasecmp(rsf->AccessControlInfo.SystemMode, "96MB") == 0 || strcasecmp(rsf->AccessControlInfo.SystemMode, "dev1") == 0)
|
|
arm11->systemMode = sysmode_96MB;
|
|
else if (strcasecmp(rsf->AccessControlInfo.SystemMode, "80MB") == 0 || strcasecmp(rsf->AccessControlInfo.SystemMode, "dev2") == 0)
|
|
arm11->systemMode = sysmode_80MB;
|
|
else if (strcasecmp(rsf->AccessControlInfo.SystemMode, "72MB") == 0 || strcasecmp(rsf->AccessControlInfo.SystemMode, "dev3") == 0)
|
|
arm11->systemMode = sysmode_72MB;
|
|
else if (strcasecmp(rsf->AccessControlInfo.SystemMode, "32MB") == 0 || strcasecmp(rsf->AccessControlInfo.SystemMode, "dev4") == 0)
|
|
arm11->systemMode = sysmode_32MB;
|
|
|
|
else {
|
|
fprintf(stderr, "[EXHEADER ERROR] Unexpected SystemMode: %s\n", rsf->AccessControlInfo.SystemMode);
|
|
return EXHDR_BAD_RSF_OPT;
|
|
}
|
|
}
|
|
|
|
/* flag[3] (Thread Priority) */
|
|
if(rsf->AccessControlInfo.Priority){
|
|
arm11->threadPriority = strtoul(rsf->AccessControlInfo.Priority,NULL,0);
|
|
if(GetAppType(rsf) == processtype_APPLICATION)
|
|
arm11->threadPriority += 32;
|
|
if(arm11->threadPriority < 0){
|
|
fprintf(stderr,"[EXHEADER ERROR] Invalid Priority: %d\n", arm11->threadPriority);
|
|
return EXHDR_BAD_RSF_OPT;
|
|
}
|
|
}
|
|
else{
|
|
ErrorParamNotFound("AccessControlInfo/Priority");
|
|
return EXHDR_BAD_RSF_OPT;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int GetAppType(rsf_settings *rsf)
|
|
{
|
|
if(rsf->SystemControlInfo.AppType){
|
|
if(strcasecmp(rsf->SystemControlInfo.AppType,"application") == 0)
|
|
return processtype_APPLICATION;
|
|
else if(strcasecmp(rsf->SystemControlInfo.AppType,"system") == 0)
|
|
return processtype_SYSTEM;
|
|
}
|
|
return processtype_APPLICATION;
|
|
}
|
|
|
|
int SetARM11ResLimitDesc(exhdr_ARM11SystemLocalCapabilities *arm11, rsf_settings *rsf)
|
|
{
|
|
for(int i = 0; i < 16; i++){
|
|
if(i == 0){
|
|
/* MaxCpu */
|
|
// N's makerom actually reads this from the pre-made accessdesc. Damn cheaters. But we can improvise
|
|
if(rsf->AccessControlInfo.MaxCpu){
|
|
arm11->resourceLimitDescriptor[i][0] = strtol(rsf->AccessControlInfo.MaxCpu,NULL,0);
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int SetARM11StorageInfo(exhdr_ARM11SystemLocalCapabilities *arm11, rsf_settings *rsf)
|
|
{
|
|
if(rsf->AccessControlInfo.AccessibleSaveDataIds){
|
|
/* Accessible SaveData IDs */
|
|
if(!CheckCondiditionsForNewAccessibleSaveDataIds(rsf))
|
|
return EXHDR_BAD_RSF_OPT;
|
|
SetARM11StorageInfoAccessibleSaveDataIds(arm11,rsf);
|
|
}
|
|
else{
|
|
/* Extdata Id */
|
|
SetARM11StorageInfoExtSaveDataId(arm11,rsf);
|
|
/* OtherUserSaveData */
|
|
SetARM11StorageInfoOtherUserSaveData(arm11,rsf);
|
|
}
|
|
|
|
/* System Savedata Id */
|
|
SetARM11StorageInfoSystemSaveDataId(arm11,rsf);
|
|
|
|
/* FileSystem Access Info */
|
|
return SetARM11StorageInfoFsAccessInfo(arm11,rsf);
|
|
}
|
|
|
|
int SetARM11StorageInfoFsAccessInfo(exhdr_ARM11SystemLocalCapabilities *arm11, rsf_settings *rsf)
|
|
{
|
|
u32 accessInfo = 0;
|
|
for(int i = 0; i < rsf->AccessControlInfo.FileSystemAccessNum; i++){
|
|
if(strcmp(rsf->AccessControlInfo.FileSystemAccess[i],"CategorySystemApplication") == 0)
|
|
accessInfo |= fsaccess_CATEGORY_SYSTEM_APPLICATION;
|
|
else if(strcmp(rsf->AccessControlInfo.FileSystemAccess[i],"CategoryHardwareCheck") == 0)
|
|
accessInfo |= fsaccess_CATEGORY_HARDWARE_CHECK;
|
|
else if(strcmp(rsf->AccessControlInfo.FileSystemAccess[i],"CategoryFileSystemTool") == 0)
|
|
accessInfo |= fsaccess_CATEGORY_FILE_SYSTEM_TOOL;
|
|
else if(strcmp(rsf->AccessControlInfo.FileSystemAccess[i],"Debug") == 0)
|
|
accessInfo |= fsaccess_DEBUG;
|
|
else if(strcmp(rsf->AccessControlInfo.FileSystemAccess[i],"TwlCardBackup") == 0)
|
|
accessInfo |= fsaccess_TWL_CARD_BACKUP;
|
|
else if(strcmp(rsf->AccessControlInfo.FileSystemAccess[i],"TwlNandData") == 0)
|
|
accessInfo |= fsaccess_TWL_NAND_DATA;
|
|
else if(strcmp(rsf->AccessControlInfo.FileSystemAccess[i],"Boss") == 0)
|
|
accessInfo |= fsaccess_BOSS;
|
|
else if(strcmp(rsf->AccessControlInfo.FileSystemAccess[i],"DirectSdmc") == 0)
|
|
accessInfo |= fsaccess_DIRECT_SDMC;
|
|
else if(strcmp(rsf->AccessControlInfo.FileSystemAccess[i],"Core") == 0)
|
|
accessInfo |= fsaccess_CORE;
|
|
else if(strcmp(rsf->AccessControlInfo.FileSystemAccess[i],"CtrNandRo") == 0)
|
|
accessInfo |= fsaccess_CTR_NAND_RO;
|
|
else if(strcmp(rsf->AccessControlInfo.FileSystemAccess[i],"CtrNandRw") == 0)
|
|
accessInfo |= fsaccess_CTR_NAND_RW;
|
|
else if(strcmp(rsf->AccessControlInfo.FileSystemAccess[i],"CtrNandRoWrite") == 0)
|
|
accessInfo |= fsaccess_CTR_NAND_RO_WRITE;
|
|
else if(strcmp(rsf->AccessControlInfo.FileSystemAccess[i],"CategorySystemSettings") == 0)
|
|
accessInfo |= fsaccess_CATEGORY_SYSTEM_SETTINGS;
|
|
else if(strcmp(rsf->AccessControlInfo.FileSystemAccess[i],"CardBoard") == 0)
|
|
accessInfo |= fsaccess_CARD_BOARD;
|
|
else if(strcmp(rsf->AccessControlInfo.FileSystemAccess[i],"ExportImportIvs") == 0)
|
|
accessInfo |= fsaccess_EXPORT_IMPORT_IVS;
|
|
else if(strcmp(rsf->AccessControlInfo.FileSystemAccess[i],"DirectSdmcWrite") == 0)
|
|
accessInfo |= fsaccess_DIRECT_SDMC_WRITE;
|
|
else if(strcmp(rsf->AccessControlInfo.FileSystemAccess[i],"SwitchCleanup") == 0)
|
|
accessInfo |= fsaccess_SWITCH_CLEANUP;
|
|
else if(strcmp(rsf->AccessControlInfo.FileSystemAccess[i],"SaveDataMove") == 0)
|
|
accessInfo |= fsaccess_SAVE_DATA_MOVE;
|
|
else if(strcmp(rsf->AccessControlInfo.FileSystemAccess[i],"Shop") == 0)
|
|
accessInfo |= fsaccess_SHOP;
|
|
else if(strcmp(rsf->AccessControlInfo.FileSystemAccess[i],"Shell") == 0)
|
|
accessInfo |= fsaccess_SHELL;
|
|
else if(strcmp(rsf->AccessControlInfo.FileSystemAccess[i],"CategoryHomeMenu") == 0)
|
|
accessInfo |= fsaccess_CATEGORY_HOME_MENU;
|
|
else{
|
|
fprintf(stderr,"[EXHEADER ERROR] Invalid FileSystemAccess Name: \"%s\"\n",rsf->AccessControlInfo.FileSystemAccess[i]);
|
|
return EXHDR_BAD_RSF_OPT;
|
|
}
|
|
}
|
|
u32_to_u8(arm11->storageInfo.accessInfo,accessInfo,LE);
|
|
|
|
return 0;
|
|
}
|
|
|
|
void SetARM11StorageInfoSystemSaveDataId(exhdr_ARM11SystemLocalCapabilities *arm11, rsf_settings *rsf)
|
|
{
|
|
if(rsf->AccessControlInfo.SystemSaveDataId1)
|
|
u32_to_u8(arm11->storageInfo.systemSavedataId[0], strtoul(rsf->AccessControlInfo.SystemSaveDataId1,NULL,0), LE);
|
|
|
|
if(rsf->AccessControlInfo.SystemSaveDataId2)
|
|
u32_to_u8(arm11->storageInfo.systemSavedataId[1], strtoul(rsf->AccessControlInfo.SystemSaveDataId2,NULL,0), LE);
|
|
}
|
|
|
|
void SetARM11StorageInfoExtSaveDataId(exhdr_ARM11SystemLocalCapabilities *arm11, rsf_settings *rsf)
|
|
{
|
|
if (rsf->AccessControlInfo.UseExtSaveData || rsf->AccessControlInfo.ExtSaveDataId) {
|
|
if (rsf->AccessControlInfo.ExtSaveDataId)
|
|
u64_to_u8(arm11->storageInfo.extSavedataId, strtoull(rsf->AccessControlInfo.ExtSaveDataId, NULL, 0), LE);
|
|
else
|
|
u32_to_u8(arm11->storageInfo.extSavedataId, GetTidUniqueId(u8_to_u64(arm11->programId,LE)), LE);
|
|
}
|
|
|
|
}
|
|
|
|
void SetARM11StorageInfoOtherUserSaveData(exhdr_ARM11SystemLocalCapabilities *arm11, rsf_settings *rsf)
|
|
{
|
|
u64 value = 0;
|
|
if(rsf->AccessControlInfo.OtherUserSaveDataId1)
|
|
value = 0xffffff & strtoul(rsf->AccessControlInfo.OtherUserSaveDataId1,NULL,0);
|
|
value = value << 20;
|
|
if(rsf->AccessControlInfo.OtherUserSaveDataId2)
|
|
value |= 0xffffff & strtoul(rsf->AccessControlInfo.OtherUserSaveDataId2,NULL,0);
|
|
value = value << 20;
|
|
if(rsf->AccessControlInfo.OtherUserSaveDataId3)
|
|
value |= 0xffffff & strtoul(rsf->AccessControlInfo.OtherUserSaveDataId3,NULL,0);
|
|
|
|
/* UseOtherVariationSaveData Flag */
|
|
if(rsf->AccessControlInfo.UseOtherVariationSaveData)
|
|
value |= 0x1000000000000000;
|
|
|
|
u64_to_u8(arm11->storageInfo.storageAccessableUniqueIds,value,LE);
|
|
}
|
|
|
|
bool CheckCondiditionsForNewAccessibleSaveDataIds(rsf_settings *rsf)
|
|
{
|
|
if(rsf->AccessControlInfo.AccessibleSaveDataIdsNum > 6){
|
|
fprintf(stderr,"[EXHEADER ERROR] Too many UniqueId in \"AccessibleSaveDataIds\".\n");
|
|
return false;
|
|
}
|
|
if (rsf->AccessControlInfo.UseExtSaveData) {
|
|
fprintf(stderr, "[EXHEADER ERROR] UseExtSaveData must be false if AccessibleSaveDataIds is specified.\n");
|
|
return false;
|
|
}
|
|
if (rsf->AccessControlInfo.ExtSaveDataId){
|
|
fprintf(stderr,"[EXHEADER ERROR] ExtSaveDataId is unavailable if AccessibleSaveDataIds is specified.\n");
|
|
return false;
|
|
}
|
|
if (rsf->AccessControlInfo.OtherUserSaveDataId1 && strtoul(rsf->AccessControlInfo.OtherUserSaveDataId1,NULL,0) > 0){
|
|
fprintf(stderr,"[EXHEADER ERROR] OtherUserSaveDataId1 must be 0 if AccessibleSaveDataIds is specified.\n");
|
|
return false;
|
|
}
|
|
if (rsf->AccessControlInfo.OtherUserSaveDataId2 && strtoul(rsf->AccessControlInfo.OtherUserSaveDataId2,NULL,0) > 0){
|
|
fprintf(stderr,"[EXHEADER ERROR] OtherUserSaveDataId2 must be 0 if AccessibleSaveDataIds is specified.\n");
|
|
return false;
|
|
}
|
|
if (rsf->AccessControlInfo.OtherUserSaveDataId3 && strtoul(rsf->AccessControlInfo.OtherUserSaveDataId3,NULL,0) > 0){
|
|
fprintf(stderr,"[EXHEADER ERROR] OtherUserSaveDataId3 must be 0 if AccessibleSaveDataIds is specified.\n");
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void SetARM11StorageInfoAccessibleSaveDataIds(exhdr_ARM11SystemLocalCapabilities *arm11, rsf_settings *rsf)
|
|
{
|
|
u64 region_ExtSaveDataId = 0;
|
|
u64 region_OtherUseSaveData = 0;
|
|
|
|
if(rsf->AccessControlInfo.AccessibleSaveDataIdsNum > 0){
|
|
u32 max = rsf->AccessControlInfo.AccessibleSaveDataIdsNum < 3 ? rsf->AccessControlInfo.AccessibleSaveDataIdsNum : 3;
|
|
for(int i = 0; i < max; i++){
|
|
u32 uniqueID = 0xffffff & strtoul(rsf->AccessControlInfo.AccessibleSaveDataIds[i],NULL,0);
|
|
region_OtherUseSaveData = region_OtherUseSaveData << 20;
|
|
region_OtherUseSaveData |= uniqueID;
|
|
}
|
|
}
|
|
if(rsf->AccessControlInfo.AccessibleSaveDataIdsNum > 3){
|
|
for(int i = 3; i < rsf->AccessControlInfo.AccessibleSaveDataIdsNum; i++){
|
|
u32 uniqueID = 0xffffff & strtoul(rsf->AccessControlInfo.AccessibleSaveDataIds[i],NULL,0);
|
|
region_ExtSaveDataId = region_ExtSaveDataId << 20;
|
|
region_ExtSaveDataId |= uniqueID;
|
|
}
|
|
}
|
|
|
|
arm11->storageInfo.otherAttributes |= attribute_USE_EXTENDED_SAVEDATA_ACCESS_CONTROL;
|
|
|
|
/* UseOtherVariationSaveData Flag */
|
|
if(rsf->AccessControlInfo.UseOtherVariationSaveData)
|
|
region_OtherUseSaveData |= 0x1000000000000000;
|
|
|
|
u64_to_u8(arm11->storageInfo.extSavedataId,region_ExtSaveDataId,LE);
|
|
u64_to_u8(arm11->storageInfo.storageAccessableUniqueIds,region_OtherUseSaveData,LE);
|
|
}
|
|
|
|
int SetARM11ServiceAccessControl(exhdr_ARM11SystemLocalCapabilities *arm11, rsf_settings *rsf)
|
|
{
|
|
if(rsf->AccessControlInfo.ServiceAccessControl){
|
|
if(rsf->AccessControlInfo.ServiceAccessControlNum > 34){
|
|
fprintf(stderr,"[EXHEADER ERROR] Too Many Service Names, maximum is 34\n");
|
|
return EXHDR_BAD_RSF_OPT;
|
|
}
|
|
for(int i = 0; i < rsf->AccessControlInfo.ServiceAccessControlNum; i++){
|
|
if(strlen(rsf->AccessControlInfo.ServiceAccessControl[i]) > 8){
|
|
fprintf(stderr,"[EXHEADER ERROR] Service Name: \"%s\" is too long\n",rsf->AccessControlInfo.ServiceAccessControl[i]);
|
|
return EXHDR_BAD_RSF_OPT;
|
|
}
|
|
strncpy((char*)arm11->serviceAccessControl[i],rsf->AccessControlInfo.ServiceAccessControl[i],8);
|
|
}
|
|
}
|
|
else{
|
|
ErrorParamNotFound("AccessControlInfo/ServiceAccessControl");
|
|
return EXHDR_BAD_RSF_OPT;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int get_ExHeaderARM11KernelInfo(exhdr_ARM11KernelCapabilities *arm11, rsf_settings *rsf)
|
|
{
|
|
int result = 0;
|
|
u16 totalDesc, descIndex;
|
|
ARM11KernelCapabilityDescriptor desc[6];
|
|
clrmem(&desc,sizeof(ARM11KernelCapabilityDescriptor)*6);
|
|
|
|
/* Get Descriptors */
|
|
if((result = SetARM11KernelDescSysCallControl(&desc[0],rsf)))
|
|
goto finish;
|
|
if((result = SetARM11KernelDescInteruptNumList(&desc[1],rsf)))
|
|
goto finish;
|
|
if((result = SetARM11KernelDescAddressMapping(&desc[2],rsf)))
|
|
goto finish;
|
|
if((result = SetARM11KernelDescOtherCapabilities(&desc[3],rsf)))
|
|
goto finish;
|
|
if((result = SetARM11KernelDescHandleTableSize(&desc[4],rsf)))
|
|
goto finish;
|
|
if((result = SetARM11KernelDescReleaseKernelVersion(&desc[5],rsf)))
|
|
goto finish;
|
|
|
|
/* Write Descriptors To Exheader */
|
|
totalDesc = 0;
|
|
for(int i = 0; i < 6; i++)
|
|
totalDesc += desc[i].num;
|
|
|
|
if(totalDesc >= 28){
|
|
fprintf(stderr,"[EXHEADER ERROR] Too many Kernel Capabilities.\n");
|
|
result = EXHDR_BAD_RSF_OPT;
|
|
goto finish;
|
|
}
|
|
|
|
descIndex = 0;
|
|
for(int i = 0; i < 6; i++){
|
|
for(int j = 0; j < desc[i].num; j++){
|
|
u32_to_u8(arm11->descriptors[descIndex],desc[i].data[j],LE);
|
|
descIndex++;
|
|
}
|
|
}
|
|
|
|
/* Fill Remaining Descriptors with 0xffffffff */
|
|
for(int i = descIndex; i < 28; i++)
|
|
u32_to_u8(arm11->descriptors[i],0xffffffff,LE);
|
|
|
|
finish:
|
|
for(int i = 0; i < 6; i++)
|
|
free(desc[i].data);
|
|
return result;
|
|
}
|
|
|
|
int SetARM11KernelDescSysCallControl(ARM11KernelCapabilityDescriptor *desc, rsf_settings *rsf)
|
|
{
|
|
int ret = 0;
|
|
u16 activeSysCallDesc, sysCallDescPos;
|
|
|
|
// Create Temporary Descriptor
|
|
ARM11KernelCapabilityDescriptor tmp;
|
|
clrmem(&tmp,sizeof(ARM11KernelCapabilityDescriptor));
|
|
|
|
AllocateARM11KernelDescMemory(&tmp,8);
|
|
for(int i = 0; i < 8; i++)
|
|
SetARM11KernelDescValue(&tmp,i,desc_SysCallControl | (i << 24));
|
|
|
|
// Get SysCalls
|
|
if((ret = GetARM11SysCalls(&tmp,rsf)))
|
|
goto finish;
|
|
|
|
// Count Active Syscall Descs
|
|
activeSysCallDesc = 0;
|
|
for(int i = 0; i < 8; i++)
|
|
if((tmp.data[i] & 0x00ffffff) != 0)
|
|
activeSysCallDesc++;
|
|
|
|
// Transfer Active Syscall Descs to out Descriptor
|
|
AllocateARM11KernelDescMemory(desc,activeSysCallDesc);
|
|
sysCallDescPos = 0;
|
|
for(int i = 0; i < 8; i++){
|
|
if((tmp.data[i] & 0x00ffffff) != 0) {
|
|
SetARM11KernelDescValue(desc,sysCallDescPos,tmp.data[i]);
|
|
sysCallDescPos++;
|
|
}
|
|
}
|
|
|
|
finish:
|
|
// Free data in Temporary Descriptor
|
|
free(tmp.data);
|
|
return ret;
|
|
}
|
|
|
|
int GetARM11SysCalls(ARM11KernelCapabilityDescriptor *desc, rsf_settings *rsf)
|
|
{
|
|
if(!rsf->AccessControlInfo.SystemCallAccess){
|
|
ErrorParamNotFound("AccessControlInfo/SystemCallAccess");
|
|
return EXHDR_BAD_RSF_OPT;
|
|
}
|
|
for(int i = 0; i < rsf->AccessControlInfo.SystemCallAccessNum; i++){
|
|
int sysCall = strtoul(rsf->AccessControlInfo.SystemCallAccess[i],NULL,0);
|
|
if(sysCall > 184){
|
|
fprintf(stderr,"[EXHEADER ERROR] Unexpected Syscall: 0x%02x. Expected Range: 0x00 - 0xB8\n",sysCall);
|
|
return EXHDR_BAD_RSF_OPT;
|
|
}
|
|
EnableSystemCall(desc,sysCall);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void EnableSystemCall(ARM11KernelCapabilityDescriptor *desc, int sysCall)
|
|
{
|
|
int num = sysCall / 24;
|
|
int num1 = sysCall % 24;
|
|
desc->data[num] |= 1 << (num1 & 31);
|
|
}
|
|
|
|
void DisableSystemCall(ARM11KernelCapabilityDescriptor *desc, int sysCall)
|
|
{
|
|
int num = sysCall / 24;
|
|
int num1 = sysCall % 24;
|
|
desc->data[num] = desc->data[num] & ~(1 << (num1 & 31));
|
|
}
|
|
|
|
int SetARM11KernelDescInteruptNumList(ARM11KernelCapabilityDescriptor *desc, rsf_settings *rsf)
|
|
{
|
|
int ret = 0;
|
|
u16 activeInteruptDesc, interuptDescPos;
|
|
|
|
// Create Temporary Descriptor
|
|
ARM11KernelCapabilityDescriptor tmp;
|
|
memset(&tmp,0,sizeof(ARM11KernelCapabilityDescriptor));
|
|
|
|
AllocateARM11KernelDescMemory(&tmp,8);
|
|
|
|
// Get Interupts
|
|
ret = GetARM11Interupts(&tmp,rsf);
|
|
if(ret) goto finish;
|
|
|
|
// Count Active Interupt Descs
|
|
activeInteruptDesc = 0;
|
|
for(int i = 0; i < 8; i++)
|
|
if(tmp.data[i])
|
|
activeInteruptDesc++;
|
|
|
|
// Transfer Active Interupt Descs to output Descriptor
|
|
AllocateARM11KernelDescMemory(desc,activeInteruptDesc);
|
|
interuptDescPos = 0;
|
|
for(int i = 0; i < 8; i++){
|
|
if(tmp.data[i]) {
|
|
SetARM11KernelDescValue(desc,interuptDescPos,(tmp.data[i] & 0x0fffffff) | desc_InteruptNumList);
|
|
interuptDescPos++;
|
|
}
|
|
}
|
|
|
|
finish:
|
|
// Free data in Temporary Descriptor
|
|
free(tmp.data);
|
|
return ret;
|
|
}
|
|
|
|
int GetARM11Interupts(ARM11KernelCapabilityDescriptor *desc, rsf_settings *rsf)
|
|
{
|
|
if(!rsf->AccessControlInfo.InterruptNumbers)
|
|
return 0;
|
|
|
|
if(rsf->AccessControlInfo.InterruptNumbersNum > 32){
|
|
fprintf(stderr,"[EXHEADER ERROR] Too many Interupts. Maximum is 32\n");
|
|
return EXHDR_BAD_RSF_OPT;
|
|
}
|
|
for(int i = 0; i < rsf->AccessControlInfo.InterruptNumbersNum; i++){
|
|
int interrupt = strtoul(rsf->AccessControlInfo.InterruptNumbers[i],NULL,0);
|
|
if(interrupt > 0x7f){
|
|
fprintf(stderr,"[EXHEADER ERROR] Unexpected Interupt: 0x%02x. Expected Range: 0x00 - 0x7f\n",interrupt);
|
|
return EXHDR_BAD_RSF_OPT;
|
|
}
|
|
EnableInterupt(desc,interrupt,i);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void EnableInterupt(ARM11KernelCapabilityDescriptor *desc, int Interrupt, int i)
|
|
{
|
|
int num = i / 4;
|
|
if(num*4 == i) desc->data[num] |= 0xffffffff;
|
|
desc->data[num] = desc->data[num] << 7;
|
|
desc->data[num] |= Interrupt;
|
|
}
|
|
|
|
int SetARM11KernelDescAddressMapping(ARM11KernelCapabilityDescriptor *desc, rsf_settings *rsf)
|
|
{
|
|
int ret = 0;
|
|
u16 memMapDescPos;
|
|
|
|
// Create Temporary Descriptors
|
|
ARM11KernelCapabilityDescriptor io_tmp;
|
|
clrmem(&io_tmp,sizeof(ARM11KernelCapabilityDescriptor));
|
|
ARM11KernelCapabilityDescriptor static_tmp;
|
|
clrmem(&static_tmp,sizeof(ARM11KernelCapabilityDescriptor));
|
|
|
|
// Getting IO Mapping
|
|
if((ret = GetARM11IOMappings(&io_tmp,rsf)))
|
|
goto finish;
|
|
|
|
// Getting Static Mapping
|
|
if((ret = GetARM11StaticMappings(&static_tmp,rsf)))
|
|
goto finish;
|
|
|
|
|
|
// Creating Output Descriptor and Combining the two MemMap Descriptors
|
|
AllocateARM11KernelDescMemory(desc,io_tmp.num+static_tmp.num);
|
|
memMapDescPos = 0;
|
|
for(int i = 0; i < io_tmp.num; i++){
|
|
SetARM11KernelDescValue(desc,memMapDescPos,io_tmp.data[i]);
|
|
memMapDescPos++;
|
|
}
|
|
for(int i = 0; i < static_tmp.num; i++){
|
|
SetARM11KernelDescValue(desc,memMapDescPos,static_tmp.data[i]);
|
|
memMapDescPos++;
|
|
}
|
|
|
|
finish:
|
|
free(io_tmp.data);
|
|
free(static_tmp.data);
|
|
return ret;
|
|
}
|
|
|
|
int GetARM11IOMappings(ARM11KernelCapabilityDescriptor *desc, rsf_settings *rsf)
|
|
{
|
|
if(!rsf->AccessControlInfo.IORegisterMapping)
|
|
return 0;
|
|
|
|
AllocateARM11KernelDescMemory(desc,rsf->AccessControlInfo.IORegisterMappingNum*2);
|
|
u16 descUsed = 0;
|
|
|
|
for(int i = 0; i < rsf->AccessControlInfo.IORegisterMappingNum; i++){
|
|
if(strlen(rsf->AccessControlInfo.IORegisterMapping[i])){
|
|
// Parse Address String
|
|
char *AddressStartStr = rsf->AccessControlInfo.IORegisterMapping[i];
|
|
char *AddressEndStr = strstr(AddressStartStr,"-");
|
|
if(AddressEndStr){
|
|
if(strlen(AddressEndStr) > 1) // if not just '-'
|
|
AddressEndStr = (AddressEndStr+1); // Setting the str to the expected start of address string
|
|
else
|
|
AddressEndStr = NULL;
|
|
}
|
|
|
|
|
|
u32 AddressStart = strtoul(AddressStartStr,NULL,16);
|
|
if(!IsStartAddress(AddressStart)){
|
|
fprintf(stderr,"[EXHEADER ERROR] Address 0x%x is not valid mapping start address.\n",AddressStart);
|
|
return EXHDR_BAD_RSF_OPT;
|
|
}
|
|
if(!AddressEndStr){ // No End Addr Was Specified
|
|
SetARM11KernelDescValue(desc,descUsed,GetIOMappingDesc(AddressStart));
|
|
descUsed++;
|
|
continue;
|
|
}
|
|
|
|
u32 AddressEnd = strtoul(AddressEndStr,NULL,16);
|
|
if(!IsEndAddress(AddressEnd)){
|
|
fprintf(stderr,"[EXHEADER ERROR] Address 0x%x is not valid mapping end address.\n",AddressEnd);
|
|
return EXHDR_BAD_RSF_OPT;
|
|
}
|
|
|
|
u32 DescStartAddr = GetStaticMappingDesc(AddressStart,false);
|
|
u32 DescEndAddr = GetStaticMappingDesc(AddressEnd+0x1000,false);
|
|
if(DescStartAddr != DescEndAddr){
|
|
SetARM11KernelDescValue(desc,descUsed,DescStartAddr);
|
|
SetARM11KernelDescValue(desc,descUsed+1,DescEndAddr);
|
|
descUsed += 2;
|
|
continue;
|
|
}
|
|
else{
|
|
SetARM11KernelDescValue(desc,descUsed,GetIOMappingDesc(AddressStart));
|
|
descUsed++;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
desc->num = descUsed;
|
|
return 0;
|
|
}
|
|
|
|
int GetARM11StaticMappings(ARM11KernelCapabilityDescriptor *desc, rsf_settings *rsf)
|
|
{
|
|
if(!rsf->AccessControlInfo.MemoryMapping)
|
|
return 0;
|
|
|
|
AllocateARM11KernelDescMemory(desc,rsf->AccessControlInfo.MemoryMappingNum*2);
|
|
u16 descUsed = 0;
|
|
for(int i = 0; i < rsf->AccessControlInfo.MemoryMappingNum; i++){
|
|
if(strlen(rsf->AccessControlInfo.MemoryMapping[i])){
|
|
char *AddressStartStr = rsf->AccessControlInfo.MemoryMapping[i];
|
|
char *AddressEndStr = strstr(AddressStartStr,"-");
|
|
char *ROFlagStr = strstr(AddressStartStr,":");
|
|
bool IsRO = false;
|
|
if(ROFlagStr)
|
|
IsRO = strcasecmp(ROFlagStr,":r") == 0 ? true : false;
|
|
|
|
if(AddressEndStr){
|
|
if(strlen(AddressEndStr) > 1) {
|
|
AddressEndStr = (AddressEndStr+1);
|
|
if(AddressEndStr == ROFlagStr)
|
|
AddressEndStr = NULL;
|
|
}
|
|
else
|
|
AddressEndStr = NULL;
|
|
}
|
|
u32 AddressStart = strtoul(AddressStartStr,NULL,16);
|
|
if(!IsStartAddress(AddressStart)){
|
|
fprintf(stderr,"[EXHEADER ERROR] Address 0x%x (%s) is not valid mapping start address.\n",AddressStart,AddressStartStr);
|
|
return EXHDR_BAD_RSF_OPT;
|
|
}
|
|
if(!AddressEndStr){ // No End Addr Was Specified
|
|
SetARM11KernelDescValue(desc,descUsed,GetStaticMappingDesc(AddressStart,IsRO));
|
|
SetARM11KernelDescValue(desc,descUsed+1,GetStaticMappingDesc(AddressStart+0x1000, true));
|
|
descUsed += 2;
|
|
continue;
|
|
}
|
|
|
|
u32 AddressEnd = strtoul(AddressEndStr,NULL,16);
|
|
if(!IsEndAddress(AddressEnd)){
|
|
fprintf(stderr,"[EXHEADER ERROR] Address 0x%x (%s) is not valid mapping end address.\n",AddressEnd,AddressEndStr);
|
|
return EXHDR_BAD_RSF_OPT;
|
|
}
|
|
|
|
u32 DescStartAddr = GetStaticMappingDesc(AddressStart,IsRO);
|
|
u32 DescEndAddr = GetStaticMappingDesc(AddressEnd+0x1000,true);
|
|
if(DescStartAddr != DescEndAddr){
|
|
SetARM11KernelDescValue(desc,descUsed,DescStartAddr);
|
|
SetARM11KernelDescValue(desc,descUsed+1,DescEndAddr);
|
|
descUsed += 2;
|
|
continue;
|
|
}
|
|
else{
|
|
SetARM11KernelDescValue(desc,descUsed,GetStaticMappingDesc(AddressStart,IsRO));
|
|
SetARM11KernelDescValue(desc,descUsed+1,GetStaticMappingDesc(AddressStart+0x1000, true));
|
|
descUsed += 2;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
desc->num = descUsed;
|
|
return 0;
|
|
}
|
|
|
|
bool IsEndAddress(u32 address)
|
|
{
|
|
return (address & 0x0fff) == 0x0fff;
|
|
}
|
|
|
|
bool IsStartAddress(u32 address)
|
|
{
|
|
return (address & 0x0fff) == 0;
|
|
}
|
|
|
|
u32 GetIOMappingDesc(u32 address)
|
|
{
|
|
return GetMappingDesc(address,0xFFE,0xC,false);
|
|
}
|
|
|
|
u32 GetStaticMappingDesc(u32 address, bool IsReadOnly)
|
|
{
|
|
return GetMappingDesc(address,0x7FC,0xB,IsReadOnly);
|
|
}
|
|
|
|
u32 GetMappingDesc(u32 address, u32 prefixVal, s32 numPrefixBits, bool IsRO)
|
|
{
|
|
u32 prefixMask = GetDescPrefixMask(numPrefixBits);
|
|
u32 prefixBits = GetDescPrefixBits(numPrefixBits,prefixVal);
|
|
u32 desc = (address >> 12 & ~prefixMask) | prefixBits;
|
|
if (IsRO)
|
|
desc |= 0x100000;
|
|
return desc;
|
|
}
|
|
|
|
int SetARM11KernelDescOtherCapabilities(ARM11KernelCapabilityDescriptor *desc, rsf_settings *rsf)
|
|
{
|
|
u32 otherCapabilities = 0;
|
|
u32 memType = 0;
|
|
|
|
if(!rsf->AccessControlInfo.DisableDebug)
|
|
otherCapabilities |= othcap_PERMIT_DEBUG;
|
|
if(rsf->AccessControlInfo.EnableForceDebug)
|
|
otherCapabilities |= othcap_FORCE_DEBUG;
|
|
if(rsf->AccessControlInfo.CanUseNonAlphabetAndNumber)
|
|
otherCapabilities |= othcap_CAN_USE_NON_ALPHABET_AND_NUMBER;
|
|
if(rsf->AccessControlInfo.CanWriteSharedPage)
|
|
otherCapabilities |= othcap_CAN_WRITE_SHARED_PAGE;
|
|
if(rsf->AccessControlInfo.CanUsePrivilegedPriority)
|
|
otherCapabilities |= othcap_CAN_USE_PRIVILEGE_PRIORITY;
|
|
if(rsf->AccessControlInfo.PermitMainFunctionArgument)
|
|
otherCapabilities |= othcap_PERMIT_MAIN_FUNCTION_ARGUMENT;
|
|
if(rsf->AccessControlInfo.CanShareDeviceMemory)
|
|
otherCapabilities |= othcap_CAN_SHARE_DEVICE_MEMORY;
|
|
if(rsf->AccessControlInfo.RunnableOnSleep)
|
|
otherCapabilities |= othcap_RUNNABLE_ON_SLEEP;
|
|
if(rsf->AccessControlInfo.SpecialMemoryArrange)
|
|
otherCapabilities |= othcap_SPECIAL_MEMORY_ARRANGE;
|
|
if (rsf->AccessControlInfo.CanAccessCore2)
|
|
otherCapabilities |= othcap_CAN_ACCESS_CORE2;
|
|
|
|
if(rsf->AccessControlInfo.MemoryType){
|
|
if(strcasecmp(rsf->AccessControlInfo.MemoryType,"application") == 0)
|
|
memType = memtype_APPLICATION;
|
|
else if(strcasecmp(rsf->AccessControlInfo.MemoryType,"system") == 0)
|
|
memType = memtype_SYSTEM;
|
|
else if(strcasecmp(rsf->AccessControlInfo.MemoryType,"base") == 0)
|
|
memType = memtype_BASE;
|
|
else{
|
|
fprintf(stderr,"[EXHEADER ERROR] Invalid memory type: \"%s\"\n",rsf->AccessControlInfo.MemoryType);
|
|
return EXHDR_BAD_RSF_OPT;
|
|
}
|
|
otherCapabilities = (otherCapabilities & 0xfffff0ff) | (memType & 0xf) << 8;
|
|
}
|
|
|
|
if(otherCapabilities){
|
|
AllocateARM11KernelDescMemory(desc,1);
|
|
SetARM11KernelDescBitmask(desc,desc_OtherCapabilities);
|
|
SetARM11KernelDescValue(desc,0,otherCapabilities);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int SetARM11KernelDescHandleTableSize(ARM11KernelCapabilityDescriptor *desc, rsf_settings *rsf)
|
|
{
|
|
if(rsf->AccessControlInfo.HandleTableSize){
|
|
u16 handleTableSize = strtoul(rsf->AccessControlInfo.HandleTableSize,NULL,0);
|
|
if(handleTableSize > 1023){
|
|
fprintf(stderr,"[EXHEADER ERROR] Too large handle table size\n");
|
|
return EXHDR_BAD_RSF_OPT;
|
|
}
|
|
AllocateARM11KernelDescMemory(desc,1);
|
|
SetARM11KernelDescBitmask(desc,desc_HandleTableSize);
|
|
SetARM11KernelDescValue(desc,0,handleTableSize);
|
|
}
|
|
else{
|
|
ErrorParamNotFound("AccessControlInfo/HandleTableSize");
|
|
return EXHDR_BAD_RSF_OPT;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int SetARM11KernelDescReleaseKernelVersion(ARM11KernelCapabilityDescriptor *desc, rsf_settings *rsf)
|
|
{
|
|
if(rsf->AccessControlInfo.ReleaseKernelMajor && rsf->AccessControlInfo.ReleaseKernelMinor){
|
|
u32 releaseKernelMajor = strtoul(rsf->AccessControlInfo.ReleaseKernelMajor,NULL,0);
|
|
u32 releaseKernelMinor = strtoul(rsf->AccessControlInfo.ReleaseKernelMinor,NULL,0);
|
|
if (releaseKernelMajor > 255 || releaseKernelMinor > 255){
|
|
fprintf(stderr,"[EXHEADER ERROR] Invalid release kernel Version");
|
|
}
|
|
AllocateARM11KernelDescMemory(desc,1);
|
|
SetARM11KernelDescBitmask(desc,desc_KernelReleaseVersion);
|
|
SetARM11KernelDescValue(desc,0,(releaseKernelMajor << 8 | releaseKernelMinor));
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void SetARM11KernelDescValue(ARM11KernelCapabilityDescriptor *desc, u16 index, u32 value)
|
|
{
|
|
if(index >= desc->num) return;
|
|
desc->data[index] |= value;
|
|
}
|
|
|
|
void SetARM11KernelDescBitmask(ARM11KernelCapabilityDescriptor *desc, u32 bitmask)
|
|
{
|
|
for(int i = 0; i < desc->num; i++)
|
|
SetARM11KernelDescValue(desc,i,bitmask);
|
|
}
|
|
|
|
void AllocateARM11KernelDescMemory(ARM11KernelCapabilityDescriptor *desc, u16 num)
|
|
{
|
|
if(num == 0) return;
|
|
desc->num = num;
|
|
desc->data = malloc(sizeof(u32)*num);
|
|
clrmem(desc->data,sizeof(u32)*num);
|
|
return;
|
|
}
|
|
|
|
u32 GetDescPrefixMask(int numPrefixBits)
|
|
{
|
|
return (u32)(~((1 << (32 - (numPrefixBits & 31))) - 1));
|
|
}
|
|
|
|
u32 GetDescPrefixBits(int numPrefixBits, u32 prefixVal)
|
|
{
|
|
return prefixVal << (32 - (numPrefixBits & 31));
|
|
}
|
|
|
|
int get_ExHeaderARM9AccessControlInfo(exhdr_ARM9AccessControlInfo *arm9, rsf_settings *rsf)
|
|
{
|
|
u32 arm9AccessControl = 0;
|
|
for(int i = 0; i < rsf->AccessControlInfo.IoAccessControlNum; i++){
|
|
if(strcmp(rsf->AccessControlInfo.IoAccessControl[i],"FsMountNand") == 0)
|
|
arm9AccessControl |= arm9cap_FS_MOUNT_NAND;
|
|
else if(strcmp(rsf->AccessControlInfo.IoAccessControl[i],"FsMountNandRoWrite") == 0)
|
|
arm9AccessControl |= arm9cap_FS_MOUNT_NAND_RO_WRITE;
|
|
else if(strcmp(rsf->AccessControlInfo.IoAccessControl[i],"FsMountTwln") == 0)
|
|
arm9AccessControl |= arm9cap_FS_MOUNT_TWLN;
|
|
else if(strcmp(rsf->AccessControlInfo.IoAccessControl[i],"FsMountWnand") == 0)
|
|
arm9AccessControl |= arm9cap_FS_MOUNT_WNAND;
|
|
else if(strcmp(rsf->AccessControlInfo.IoAccessControl[i],"FsMountCardSpi") == 0)
|
|
arm9AccessControl |= arm9cap_FS_MOUNT_CARD_SPI;
|
|
else if(strcmp(rsf->AccessControlInfo.IoAccessControl[i],"UseSdif3") == 0)
|
|
arm9AccessControl |= arm9cap_USE_SDIF3;
|
|
else if(strcmp(rsf->AccessControlInfo.IoAccessControl[i],"CreateSeed") == 0)
|
|
arm9AccessControl |= arm9cap_CREATE_SEED;
|
|
else if(strcmp(rsf->AccessControlInfo.IoAccessControl[i],"UseCardSpi") == 0)
|
|
arm9AccessControl |= arm9cap_USE_CARD_SPI;
|
|
else{
|
|
fprintf(stderr,"[EXHEADER ERROR] Invalid IoAccessControl Name: \"%s\"\n",rsf->AccessControlInfo.IoAccessControl[i]);
|
|
return EXHDR_BAD_RSF_OPT;
|
|
}
|
|
}
|
|
|
|
for(int i = 0; i < rsf->AccessControlInfo.FileSystemAccessNum; i++){
|
|
if(strcmp(rsf->AccessControlInfo.FileSystemAccess[i],"DirectSdmc") == 0)
|
|
arm9AccessControl |= arm9cap_USE_DIRECT_SDMC;
|
|
}
|
|
|
|
if(rsf->Option.UseOnSD)
|
|
arm9AccessControl |= arm9cap_SD_APPLICATION;
|
|
|
|
u32_to_u8(arm9->descriptors,arm9AccessControl,LE);
|
|
|
|
if(rsf->AccessControlInfo.DescVersion)
|
|
arm9->descriptors[15] = strtol(rsf->AccessControlInfo.DescVersion,NULL,0);
|
|
else{
|
|
//ErrorParamNotFound("AccessControlInfo/DescVersion");
|
|
//return EXHDR_BAD_RSF_OPT;
|
|
arm9->descriptors[15] = 2; // Makerom generates a desc version 2 anyway, so if not specified, it will be set to 2
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* Generic Exheader Errors */
|
|
void ErrorParamNotFound(char *string)
|
|
{
|
|
fprintf(stderr,"[EXHEADER ERROR] Parameter Not Found: \"%s\"\n",string);
|
|
}
|
|
|
|
/* ExHeader Binary Print Functions */
|
|
void exhdr_Print_ServiceAccessControl(extended_hdr *hdr)
|
|
{
|
|
printf("[+] Service Access Control\n");
|
|
for(int i = 0; i < 32; i ++){
|
|
char *SVC_Handle = (char*)hdr->arm11SystemLocalCapabilities.serviceAccessControl[i];
|
|
if(SVC_Handle[0] == 0) break;
|
|
printf("%.8s\n",hdr->arm11SystemLocalCapabilities.serviceAccessControl[i]);
|
|
}
|
|
}
|
|
|
|
/* ExHeader Binary Read Functions */
|
|
u8* GetAcexRsaSig(access_descriptor *acexDesc)
|
|
{
|
|
return acexDesc->signature ;
|
|
}
|
|
|
|
u8* GetAcexNcchPubKey(access_descriptor *acexDesc)
|
|
{
|
|
return acexDesc->ncchRsaPubKey;
|
|
}
|
|
|
|
u16 GetRemasterVersion_frm_exhdr(extended_hdr *hdr)
|
|
{
|
|
return u8_to_u16(hdr->codeSetInfo.remasterVersion,LE);
|
|
}
|
|
|
|
u64 GetSaveDataSize_frm_exhdr(extended_hdr *hdr)
|
|
{
|
|
return u8_to_u64(hdr->systemInfo.savedataSize,LE);
|
|
}
|
|
|
|
void GetCoreVersion_frm_exhdr(u8 *Dest, extended_hdr *hdr)
|
|
{
|
|
memcpy(Dest,hdr->arm11SystemLocalCapabilities.coreVersion,4);
|
|
}
|
|
|
|
int GetDependencyList_frm_exhdr(u8 *Dest, extended_hdr *hdr)
|
|
{
|
|
if(!Dest) return -1;
|
|
memcpy(Dest,hdr->dependencyList,0x30*8);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* ExHeader Settings Read from RSF */
|
|
int GetSaveDataSizeFromString(u64 *out, char *string, char *moduleName)
|
|
{
|
|
if(!string){
|
|
*out = 0;
|
|
return 0;
|
|
}
|
|
|
|
u64 SaveDataSize = strtoull(string,NULL,10);
|
|
|
|
if(strstr(string,"K")){
|
|
char *str = strstr(string,"K");
|
|
if(strcmp(str,"K") == 0 || strcmp(str,"KB") == 0 ){
|
|
SaveDataSize *= KB;
|
|
}
|
|
}
|
|
else if(strstr(string,"M")){
|
|
char *str = strstr(string,"M");
|
|
if(strcmp(str,"M") == 0 || strcmp(str,"MB") == 0 ){
|
|
SaveDataSize *= MB;
|
|
}
|
|
}
|
|
else if(strstr(string,"G")){
|
|
char *str = strstr(string,"G");
|
|
if(strcmp(str,"G") == 0 || strcmp(str,"GB") == 0 ){
|
|
SaveDataSize *= GB;
|
|
}
|
|
}
|
|
else{
|
|
if(moduleName)
|
|
fprintf(stderr,"[%s ERROR] Invalid save data size format.\n",moduleName);
|
|
else
|
|
fprintf(stderr,"[ERROR] Invalid save data size format.\n");
|
|
return EXHDR_BAD_RSF_OPT;
|
|
}
|
|
if((SaveDataSize & 65536) != 0){
|
|
if(moduleName)
|
|
fprintf(stderr,"[%s ERROR] Save data size must be aligned to 64K.\n",moduleName);
|
|
else
|
|
fprintf(stderr,"[ERROR] Save data size must be aligned to 64K.\n");
|
|
return EXHDR_BAD_RSF_OPT;
|
|
}
|
|
*out = SaveDataSize;
|
|
return 0;
|
|
}
|
|
|
|
int GetSaveDataSize_rsf(u64 *SaveDataSize, user_settings *usrset)
|
|
{
|
|
|
|
if(usrset->common.rsfSet.SystemControlInfo.SaveDataSize){
|
|
*SaveDataSize = strtoull(usrset->common.rsfSet.SystemControlInfo.SaveDataSize,NULL,10);
|
|
if(strstr(usrset->common.rsfSet.SystemControlInfo.SaveDataSize,"K")){
|
|
char *str = strstr(usrset->common.rsfSet.SystemControlInfo.SaveDataSize,"K");
|
|
if(strcmp(str,"K") == 0 || strcmp(str,"KB") == 0 ){
|
|
*SaveDataSize = *SaveDataSize*KB;
|
|
}
|
|
}
|
|
else if(strstr(usrset->common.rsfSet.SystemControlInfo.SaveDataSize,"M")){
|
|
char *str = strstr(usrset->common.rsfSet.SystemControlInfo.SaveDataSize,"M");
|
|
if(strcmp(str,"M") == 0 || strcmp(str,"MB") == 0 ){
|
|
*SaveDataSize = *SaveDataSize*MB;
|
|
}
|
|
}
|
|
else if(strstr(usrset->common.rsfSet.SystemControlInfo.SaveDataSize,"G")){
|
|
char *str = strstr(usrset->common.rsfSet.SystemControlInfo.SaveDataSize,"G");
|
|
if(strcmp(str,"G") == 0 || strcmp(str,"GB") == 0 ){
|
|
*SaveDataSize = *SaveDataSize*GB;
|
|
}
|
|
}
|
|
else{
|
|
fprintf(stderr,"[EXHEADER ERROR] Invalid save data size format.\n");
|
|
return EXHDR_BAD_RSF_OPT;
|
|
}
|
|
if((*SaveDataSize & 65536) != 0){
|
|
fprintf(stderr,"[EXHEADER ERROR] Save data size must be aligned to 64K.\n");
|
|
return EXHDR_BAD_RSF_OPT;
|
|
}
|
|
}
|
|
else{
|
|
*SaveDataSize = 0;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int GetRemasterVersion_rsf(u16 *RemasterVersion, user_settings *usrset)
|
|
{
|
|
char *Str = usrset->common.rsfSet.SystemControlInfo.RemasterVersion;
|
|
if(!Str){
|
|
*RemasterVersion = 0;
|
|
return 0;
|
|
}
|
|
*RemasterVersion = strtol(Str,NULL,0);
|
|
return 0;
|
|
}
|