static Result AM_GetSmdh(AM_TitleMediaEntry* title)
{
if (!title || title->smdh) return -1;
Result ret;
u32 bytesRead;
Handle fileHandle;
debug_print("AM_GetSmdh:\n");
u32 archivePath[] = { title->titleid & 0xFFFFFFFF, (title->titleid >> 32) & 0xFFFFFFFF, title->mediatype, 0x00000000 };
u32 filePath[] = { 0x00000000, 0x00000000, 0x00000002, 0x6E6F6369, 0x00000000 };
ret = FSUSER_OpenFileDirectly(&fileHandle, (FS_Archive) { ARCHIVE_SAVEDATA_AND_CONTENT , (FS_Path) { PATH_BINARY, 16, archivePath } }, (FS_Path) { PATH_BINARY, 20, filePath }, FS_OPEN_READ, FS_ATTRIBUTE_NONE);
r(" > FSUSER_OpenFileDirectly: %lx\n", ret);
if (R_SUCCEEDED(ret))
{
title->smdh = (smdh_s*) malloc(sizeof(smdh_s));
ret = FSFILE_Read(fileHandle, &bytesRead, 0LL, title->smdh, sizeof(smdh_s));
r(" > FSFILE_Read: %lx\n", ret);
}
if (R_FAILED(ret))
{
free(title->smdh);
title->smdh = NULL;
}
FSFILE_Close(fileHandle);
r(" > FSFILE_Close\n");
return ret;
}
u8* loadSmdh(u64 tid, u8 mediatype)
{
Result ret;
Handle fileHandle;
u32 archivePath[] = {tid & 0xFFFFFFFF, (tid >> 32) & 0xFFFFFFFF, mediatype, 0x00000000};
static const u32 filePath[] = {0x00000000, 0x00000000, 0x00000002, 0x6E6F6369, 0x00000000}; // icon
ret = FSUSER_OpenFileDirectly(NULL, &fileHandle, (FS_archive){0x2345678a, (FS_path){PATH_BINARY, 0x10, (u8*)archivePath}}, (FS_path){PATH_BINARY, 0x14, (u8*)filePath}, FS_OPEN_READ, FS_ATTRIBUTE_NONE);
printf("loading smdh : %08X\n", (unsigned int)ret);
u8* fileBuffer = NULL;
u64 fileSize = 0;
{
u32 bytesRead;
ret = FSFILE_GetSize(fileHandle, &fileSize);
if(ret)return NULL;
fileBuffer = malloc(fileSize);
if(ret)return NULL;
ret = FSFILE_Read(fileHandle, &bytesRead, 0x0, fileBuffer, fileSize);
if(ret)return NULL;
ret = FSFILE_Close(fileHandle);
if(ret)return NULL;
printf("loaded code : %08X\n", (unsigned int)fileSize);
}
return fileBuffer;
}
void NES_LoadSelectedGame() {
u32 bytesRead = 0;
u32 SRAM_Size = 0;
u32 ROMDIR_Size = (strlen("/3DNES/ROMS/") + strlen(fileSystem.fileList[fileSystem.currFile]) + 1);
Handle fileHandle;
CPU_Running = false;
/* Alloc ROM Directory */
char ROM_DIR[ROMDIR_Size];
/* Clear ROM_Dir */
memset(ROM_DIR, 0x0, ROMDIR_Size);
//FS_StringConc(ROM_DIR, "/3DNES/ROMS/", fileSystem.fileList[fileSystem.currFile]);
/* TODO: FIX IT
/*if (SRAM_Name != NULL) {
linearFree(SRAM_Name);
SRAM_Size = (strlen(fileSystem.fileList[fileSystem.currFile]) - 4);
SRAM_Name = linearAlloc(SRAM_Size);
strncpy((char*)SRAM_Name, fileSystem.fileList[fileSystem.currFile], SRAM_Size);
}
*/
FSUSER_OpenFileDirectly(NULL, &fileHandle, sdmcArchive, FS_makePath(PATH_CHAR, ROM_DIR), FS_OPEN_READ, FS_ATTRIBUTE_NONE);
FSFILE_GetSize(fileHandle, &ROM_Size);
FSFILE_Read(fileHandle, &bytesRead, 0x0, (u32*)ROM_Cache, (u32)ROM_Size);
FSFILE_Close(fileHandle);
/* Start Emulation */
inGame = true;
}
static int lua_addCert(lua_State *L)
{
int argc = lua_gettop(L);
#ifndef SKIP_ERROR_HANDLING
if (argc != 1) return luaL_error(L, "wrong number of arguments");
#endif
const char *text = luaL_checkstring(L, 1);
fileStream fileHandle;
if (strncmp("romfs:/",text,7) == 0){
fileHandle.isRomfs = true;
FILE* handle = fopen(text,"r");
#ifndef SKIP_ERROR_HANDLING
if (handle == NULL) return luaL_error(L, "file doesn't exist.");
#endif
fileHandle.handle = (u32)handle;
}else{
fileHandle.isRomfs = false;
FS_Path filePath = fsMakePath(PATH_ASCII, text);
FS_Archive script=(FS_Archive){ARCHIVE_SDMC, (FS_Path){PATH_EMPTY, 1, (u8*)""}};
Result ret = FSUSER_OpenFileDirectly( &fileHandle.handle, script, filePath, FS_OPEN_READ, 0x00000000);
#ifndef SKIP_ERROR_HANDLING
if (ret) return luaL_error(L, "file doesn't exist.");
#endif
}
u64 cert_size;
u32 bytesRead;
FS_GetSize(&fileHandle, &cert_size);
u8* cert = (u8*)malloc(cert_size);
FS_Read(&fileHandle, &bytesRead, 0, cert, cert_size);
sslcAddTrustedRootCA(RootCertChain_contexthandle, cert, cert_size, NULL);
free(cert);
FS_Close(&fileHandle);
return 0;
}
Result loadTitleInfoIcon(titleInfo_s* ti)
{
if(!ti || ti->icon)return -1;
ti->icon = malloc(sizeof(smdh_s));
if(!ti->icon)return -1;
Handle fileHandle;
u32 archivePath[] = {ti->title_id & 0xFFFFFFFF, (ti->title_id >> 32) & 0xFFFFFFFF, ti->mediatype, 0x00000000};
static const u32 filePath[] = {0x00000000, 0x00000000, 0x00000002, 0x6E6F6369, 0x00000000};
Result ret = FSUSER_OpenFileDirectly(&fileHandle, (FS_Archive){ARCHIVE_SAVEDATA_AND_CONTENT, (FS_Path){PATH_BINARY, 0x10, (u8*)archivePath}}, (FS_Path){PATH_BINARY, 0x14, (u8*)filePath}, FS_OPEN_READ, 0);
if(ret)
{
free(ti->icon);
ti->icon = NULL;
return ret;
}
u32 bytesRead;
ret = FSFILE_Read(fileHandle, &bytesRead, 0x0, ti->icon, sizeof(smdh_s));
if(ret)
{
free(ti->icon);
ti->icon = NULL;
}
FSFILE_Close(fileHandle);
return ret;
}
static bool ndspFindAndLoadComponent(void)
{
Result rc;
Handle rsrc;
void* bin;
componentProgMask = 0xFF;
componentDataMask = 0xFF;
// Try loading the DSP component from the filesystem
do
{
static const char dsp_filename[] = "/3ds/dspfirm.cdc";
FS_Archive arch = { ARCHIVE_SDMC, { PATH_EMPTY, 1, (u8*)"" }, 0 };
FS_Path path = { PATH_ASCII, sizeof(dsp_filename), (u8*)dsp_filename };
rc = FSUSER_OpenFileDirectly(&rsrc, arch, path, FS_OPEN_READ, 0);
if (R_FAILED(rc)) break;
u64 size = 0;
rc = FSFILE_GetSize(rsrc, &size);
if (R_FAILED(rc)) { FSFILE_Close(rsrc); break; }
bin = malloc(size);
if (!bin) { FSFILE_Close(rsrc); break; }
u32 dummy = 0;
rc = FSFILE_Read(rsrc, &dummy, 0, bin, size);
FSFILE_Close(rsrc);
if (R_FAILED(rc)) { free(bin); return false; }
componentBin = bin;
componentSize = size;
componentFree = true;
return true;
} while (0);
// Try loading the DSP component from hb:ndsp
rsrc = envGetHandle("hb:ndsp");
if (rsrc) do
{
extern u32 fake_heap_end;
u32 mapAddr = (fake_heap_end+0xFFF) &~ 0xFFF;
rc = svcMapMemoryBlock(rsrc, mapAddr, 0x3, 0x3);
if (R_FAILED(rc)) break;
componentSize = *(u32*)(mapAddr + 0x104);
bin = malloc(componentSize);
if (bin)
memcpy(bin, (void*)mapAddr, componentSize);
svcUnmapMemoryBlock(rsrc, mapAddr);
if (!bin) break;
componentBin = bin;
componentFree = true;
return true;
} while (0);
return false;
}
static Result __read_versionbin(FS_ArchiveID archiveId, FS_Path archivePath, FS_Path fileLowPath, OS_VersionBin *versionbin)
{
Result ret = 0;
Handle filehandle = 0;
FILE *f = NULL;
struct romfs_mount *mount;
ret = FSUSER_OpenFileDirectly(&filehandle, archiveId, archivePath, fileLowPath, FS_OPEN_READ, 0x0);
if(R_FAILED(ret))return ret;
ret = romfsMountFromFile(filehandle, 0x0, &mount);
if(R_FAILED(ret))return ret;
f = fopen("romfs:/version.bin", "r");
if(f==NULL)
{
ret = errno;
}
else
{
if(fread(versionbin, 1, sizeof(OS_VersionBin), f) != sizeof(OS_VersionBin))ret = -10;
fclose(f);
}
romfsUnmount(mount);
return ret;
}
std::vector<TitleInfo> getTitleInfos(FS_MediaType mediaType)
{
char tmpStr[16];
extern u8 sysLang; // We got this in main.c
u32 count, bytesRead;
Result res;
Handle fileHandle;
TitleInfo tmpTitleInfo;
u32 archiveLowPath[4] = {0, 0, mediaType, 0};
const FS_Archive iconArchive = {0x2345678A, {PATH_BINARY, 0x10, (u8*)archiveLowPath}};
const u32 fileLowPath[5] = {0, 0, 2, 0x6E6F6369, 0};
const FS_Path filePath = {PATH_BINARY, 0x14, (const u8*)fileLowPath};
if((res = AM_GetTitleCount(mediaType, &count))) throw titleException(_FILE_, __LINE__, res, "Failed to get title count!");
std::vector<TitleInfo> titleInfos; titleInfos.reserve(count);
Buffer<u64> titleIdList(count, false);
Buffer<AM_TitleEntry> titleList(count, false);
Buffer<Icon> icon(1, false);
if((res = AM_GetTitleIdList(mediaType, count, &titleIdList))) throw titleException(_FILE_, __LINE__, res, "Failed to get title ID list!");
if((res = AM_ListTitles(mediaType, count, &titleIdList, &titleList))) throw titleException(_FILE_, __LINE__, res, "Failed to get title list!");
for(u32 i=0; i<count; i++)
{
// Copy title ID, size and version directly
memcpy(&tmpTitleInfo.titleID, &titleList[i].titleID, 18);
if(AM_GetTitleProductCode(mediaType, titleIdList[i], tmpStr)) memset(tmpStr, 0, 16);
tmpTitleInfo.productCode = tmpStr;
// Copy the title ID into our archive low path
memcpy(archiveLowPath, &titleIdList[i], 8);
icon.clear();
if(!FSUSER_OpenFileDirectly(&fileHandle, iconArchive, filePath, FS_OPEN_READ, 0))
{
// Nintendo decided to release a title with an icon entry but with size 0 so this will fail.
// Ignoring errors because of this here.
FSFILE_Read(fileHandle, &bytesRead, 0, &icon, sizeof(Icon));
FSFILE_Close(fileHandle);
}
tmpTitleInfo.title = icon[0].appTitles[sysLang].longDesc;
tmpTitleInfo.publisher = icon[0].appTitles[sysLang].publisher;
memcpy(tmpTitleInfo.icon, icon[0].icon48, 0x1200);
titleInfos.push_back(tmpTitleInfo);
}
return titleInfos;
}
void runHbmenu()
{
// grab fs:USER handle
int i;
Handle fsuHandle = 0x0;
for(i=0; i<_serviceList.num; i++)if(!strcmp(_serviceList.services[i].name, "fs:USER"))fsuHandle=_serviceList.services[i].handle;
if(!fsuHandle)*(u32*)0xCAFE0002=0;
Handle fileHandle;
FS_archive sdmcArchive = (FS_archive){0x9, (FS_path){PATH_EMPTY, 1, (u8*)""}};
// FS_path filePath = (FS_path){PATH_CHAR, 18, (u8*)"/3ds_hb_menu.3dsx"};
FS_path filePath = (FS_path){PATH_CHAR, 11, (u8*)"/boot.3dsx"};
Result ret = FSUSER_OpenFileDirectly(fsuHandle, &fileHandle, sdmcArchive, filePath, FS_OPEN_READ, FS_ATTRIBUTE_NONE);
run3dsx(fileHandle, NULL);
}
Result loadGamecardIcon(smdh_s* out)
{
if(!out)return -1;
Handle fileHandle;
static const u32 archivePath[] = {0x00000000, 0x00000000, 0x00000002, 0x00000000};
static const u32 filePath[] = {0x00000000, 0x00000000, 0x00000002, 0x6E6F6369, 0x00000000};
Result ret = FSUSER_OpenFileDirectly(&fileHandle, (FS_Archive){0x2345678a, (FS_Path){PATH_BINARY, 0x10, (u8*)archivePath}}, (FS_Path){PATH_BINARY, 0x14, (u8*)filePath}, FS_OPEN_READ, 0);
if(ret)return ret;
u32 bytesRead;
ret = FSFILE_Read(fileHandle, &bytesRead, 0x0, out, sizeof(smdh_s));
FSFILE_Close(fileHandle);
return ret;
}
static Result action_import_twl_save_open_src(void* data, u32 index, u32* handle) {
import_twl_save_data* importData = (import_twl_save_data*) data;
Result res = 0;
char path[FILE_PATH_MAX];
snprintf(path, sizeof(path), "/fbi/save/%s.sav", importData->title->productCode);
FS_Path* fsPath = util_make_path_utf8(path);
if(fsPath != NULL) {
res = FSUSER_OpenFileDirectly(handle, ARCHIVE_SDMC, fsMakePath(PATH_EMPTY, ""), *fsPath, FS_OPEN_READ, 0);
util_free_path_utf8(fsPath);
} else {
res = R_FBI_OUT_OF_MEMORY;
}
return res;
}
static int lua_download(lua_State *L){
int argc = lua_gettop(L);
#ifndef SKIP_ERROR_HANDLING
if (argc != 2) return luaL_error(L, "wrong number of arguments");
#endif
const char* url = luaL_checkstring(L,1);
const char* file = luaL_checkstring(L,2);
httpcContext context;
Result ret = httpcOpenContext(&context, (char*)url , 0);
#ifndef SKIP_ERROR_HANDLING
if(ret==0){
#endif
httpcBeginRequest(&context);
/*httpcReqStatus loading;
httpcGetRequestState(&context, &loading);
while (loading == 0x5){
httpcGetRequestState(&context, &loading);
}*/
u32 statuscode=0;
u32 contentsize=0;
httpcGetResponseStatusCode(&context, &statuscode, 0);
#ifndef SKIP_ERROR_HANDLING
if (statuscode != 200) luaL_error(L, "download request error");
#endif
httpcGetDownloadSizeState(&context, NULL, &contentsize);
u8* buf = (u8*)malloc(contentsize);
memset(buf, 0, contentsize);
httpcDownloadData(&context, buf, contentsize, NULL);
Handle fileHandle;
u32 bytesWritten;
FS_Archive sdmcArchive=(FS_Archive){ARCHIVE_SDMC, (FS_Path){PATH_EMPTY, 1, (u8*)""}};
FS_Path filePath=fsMakePath(PATH_ASCII, file);
FSUSER_OpenFileDirectly( &fileHandle, sdmcArchive, filePath, FS_OPEN_CREATE|FS_OPEN_WRITE, 0x00000000);
FSFILE_Write(fileHandle, &bytesWritten, 0, buf, contentsize,0x10001);
FSFILE_Close(fileHandle);
svcCloseHandle(fileHandle);
free(buf);
#ifndef SKIP_ERROR_HANDLING
}else luaL_error(L, "error opening url");
#endif
httpcCloseContext(&context);
return 0;
}
int main()
{
initSrv();
aptInit(APPID_APPLICATION);
gspGpuInit();
hidInit(NULL);
Handle fsuHandle;
srv_getServiceHandle(NULL, &fsuHandle, "fs:USER");
FSUSER_Initialize(fsuHandle);
Handle fileHandle;
u32 bytesRead;
FS_archive sdmcArchive=(FS_archive){0x9, (FS_path){PATH_EMPTY, 1, (u8*)""}};
FS_path filePath=(FS_path){PATH_CHAR, 10, (u8*)"/test.bin"};
FSUSER_OpenFileDirectly(fsuHandle, &fileHandle, sdmcArchive, filePath, FS_OPEN_READ, FS_ATTRIBUTE_NONE);
FSFILE_Read(fileHandle, &bytesRead, 0x0, (u32*)gspHeap, 0x46500);
FSFILE_Close(fileHandle);
aptSetupEventHandler();
while(!aptGetStatus())
{
u32 PAD=hidSharedMem[7];
renderEffect();
swapBuffers();
copyBuffer();
u32 regData=PAD|0x01000000;
GSPGPU_WriteHWRegs(NULL, 0x202A04, ®Data, 4);
svc_sleepThread(1000000000);
}
svc_closeHandle(fsuHandle);
hidExit();
gspGpuInit();
aptExit();
svc_exitProcess();
return 0;
}
void DumpSharedRomFS(u8* archive_binary_lowpath) {
std::string output_file = BuildSharedRomFSFilename(archive_binary_lowpath);
// Read RomFS bin from SaveDataCheck...
Handle romfs_handle;
u64 romfs_size = 0;
u32 romfs_bytes_read = 0;
FS_archive savedatacheck_archive = { 0x2345678a, { PATH_BINARY, 16, archive_binary_lowpath } };
u8 file_binary_lowpath[20] = {};
FS_path romfs_path = { PATH_BINARY, 20, file_binary_lowpath };
print(GFX_TOP, "Dumping SaveDataCheck RomFS (%s)... ", output_file.c_str());
FSUSER_OpenFileDirectly(NULL, &romfs_handle, savedatacheck_archive, romfs_path, FS_OPEN_READ, FS_ATTRIBUTE_NONE);
FSFILE_GetSize(romfs_handle, &romfs_size);
std::unique_ptr<u8> romfs_data_buffer(new u8[romfs_size]);
FSFILE_Read(romfs_handle, &romfs_bytes_read, 0, romfs_data_buffer.get(), romfs_size);
FSFILE_Close(romfs_handle);
// Dump RomFS bin to SDMC...
Handle file_handle;
u32 bytes_written = 0;
FS_path fs_path = FS_makePath(PATH_CHAR, output_file.c_str());
FS_archive sdmc_archive = (FS_archive) { 0x00000009, { PATH_EMPTY, 1, (u8*) "" } };
FSUSER_OpenArchive(NULL, &sdmc_archive);
FSUSER_OpenFile(NULL, &file_handle, sdmc_archive, fs_path, FS_OPEN_CREATE | FS_OPEN_WRITE, FS_ATTRIBUTE_NONE);
Result res = FSFILE_Write(file_handle, &bytes_written, 0x0, romfs_data_buffer.get(), romfs_size, FS_WRITE_FLUSH);
FSFILE_Close(file_handle);
FSUSER_CloseArchive(NULL, &sdmc_archive);
// Check result...
if (res == 0 && bytes_written == romfs_size)
print(GFX_TOP, "Done!\n");
else
print(GFX_TOP, "Failed!\n");
}
s32 main (void) {
// Initialize services
srvInit();
aptInit();
hidInit(NULL);
gfxInitDefault();
fsInit();
sdmcInit();
hbInit();
qtmInit();
Handle fileHandle;
u32 bytesRead;
FS_archive sdmcArchive=(FS_archive){ARCH_SDMC, (FS_path){PATH_EMPTY, 1, (u8*)""}};
FS_path filePath=FS_makePath(PATH_CHAR, "/rxTools.dat");
Result ret=FSUSER_OpenFileDirectly(NULL, &fileHandle, sdmcArchive, filePath, FS_OPEN_READ, FS_ATTRIBUTE_NONE);
if(ret) goto EXIT;
FSFILE_Read(fileHandle, &bytesRead, 0x20000, 0x14400000, 320*1024);
FSFILE_Close(fileHandle);
consoleInit(GFX_BOTTOM, NULL);
if (brahma_init()) {
quick_boot_firm(1);
printf("[!] Quickload failed\n");
brahma_exit();
} else {
printf("* BRAHMA *\n\n[!]Not enough memory\n");
wait_any_key();
}
EXIT:
hbExit();
sdmcExit();
fsExit();
gfxExit();
hidExit();
aptExit();
srvExit();
// Return to hbmenu
return 0;
}
s32 main(void) {
// Initialize services
srvInit();
aptInit();
hidInit(NULL);
gfxInitDefault();
gfxSet3D(true);
fsInit();
sdmcInit();
hbInit();
qtmInit();
gfxSwapBuffers();
Handle fileHandle;
u32 bytesRead;
FS_archive sdmcArchive = (FS_archive){ ARCH_SDMC, (FS_path){ PATH_EMPTY, 1, (u8*)"" } };
FS_path filePath = FS_makePath(PATH_CHAR, "/" CODE_PATH);
Result ret = FSUSER_OpenFileDirectly(NULL, &fileHandle, sdmcArchive, filePath, FS_OPEN_READ, FS_ATTRIBUTE_NONE);
if (ret) goto EXIT;
FSFILE_Read(fileHandle, &bytesRead, 0x14000, 0x14400000, 320 * 1024);
FSFILE_Close(fileHandle);
if (brahma_init())
{
quick_boot_firm(1);
brahma_exit();
}
EXIT:
hbExit();
sdmcExit();
fsExit();
gfxExit();
hidExit();
aptExit();
srvExit();
// Return to hbmenu
return 0;
}
static int lua_loadBMPV(lua_State *L)
{
int argc = lua_gettop(L);
if (argc != 1) return luaL_error(L, "wrong number of arguments");
const char *file_tbo = luaL_checkstring(L, 1);
Handle fileHandle;
FS_archive sdmcArchive=(FS_archive){ARCH_SDMC, (FS_path){PATH_EMPTY, 1, (u8*)""}};
FS_path filePath=FS_makePath(PATH_CHAR, file_tbo);
Result ret=FSUSER_OpenFileDirectly(NULL, &fileHandle, sdmcArchive, filePath, FS_OPEN_READ, FS_ATTRIBUTE_NONE);
if(ret) return luaL_error(L, "error opening file");
u32 magic,frame_size,bytesRead;
u64 size;
FSFILE_GetSize(fileHandle, &size);
FSFILE_Read(fileHandle, &bytesRead, 0, &magic, 4);
if (magic == 0x56504D42){
BMPV* BMPV_file = (BMPV*)malloc(sizeof(BMPV));
FSFILE_Read(fileHandle, &bytesRead, 4, &(BMPV_file->framerate), 4);
FSFILE_Read(fileHandle, &bytesRead, 8, &(BMPV_file->width), 4);
FSFILE_Read(fileHandle, &bytesRead, 12,&(BMPV_file->height), 4);
if (!GW_MODE) FSFILE_Read(fileHandle, &bytesRead, 16,&(BMPV_file->audiotype), 2);
FSFILE_Read(fileHandle, &bytesRead, 18,&(BMPV_file->bytepersample), 2);
FSFILE_Read(fileHandle, &bytesRead, 20,&(BMPV_file->samplerate), 4);
FSFILE_Read(fileHandle, &bytesRead, 24,&(BMPV_file->audio_size), 4);
BMPV_file->isPlaying = false;
BMPV_file->currentFrame = 0;
BMPV_file->sourceFile = fileHandle;
BMPV_file->tick = 0;
BMPV_file->audiobuf = NULL;
BMPV_file->audiobuf2 = NULL;
frame_size = BMPV_file->width*BMPV_file->height*3;
u8* framebuf = (u8*)(malloc(frame_size));
BMPV_file->framebuf = framebuf;
int tot_frame = (size-28-BMPV_file->audio_size)/frame_size;
BMPV_file->mem_size = BMPV_file->audio_size;
BMPV_file->tot_frame = tot_frame;
lua_pushnumber(L, (u32)BMPV_file);
}
return 1;
}
void task_populate_titledb_update_status(list_item* item) {
titledb_info* info = (titledb_info*) item->data;
info->cia.installed = false;
info->tdsx.installed = false;
if(info->cia.exists) {
AM_TitleEntry entry;
info->cia.installed = R_SUCCEEDED(AM_GetTitleInfo(fs_get_title_destination(info->cia.titleId), 1, &info->cia.titleId, &entry))
&& task_populate_titledb_cache_get(info->id, true, &info->cia.installedInfo);
}
if(info->tdsx.exists) {
char path3dsx[FILE_PATH_MAX];
fs_make_3dsx_path(path3dsx, info->meta.shortDescription, sizeof(path3dsx));
FS_Path* fsPath = fs_make_path_utf8(path3dsx);
if(fsPath != NULL) {
Handle handle = 0;
if(R_SUCCEEDED(FSUSER_OpenFileDirectly(&handle, ARCHIVE_SDMC, fsMakePath(PATH_EMPTY, ""), *fsPath, FS_OPEN_READ, 0))) {
FSFILE_Close(handle);
info->tdsx.installed = task_populate_titledb_cache_get(info->id, false, &info->tdsx.installedInfo);
}
fs_free_path_utf8(fsPath);
}
}
if((info->cia.installed && info->cia.installedInfo.id != info->cia.id) || (info->tdsx.installed && info->tdsx.installedInfo.id != info->tdsx.id)) {
item->color = COLOR_TITLEDB_OUTDATED;
} else if(info->cia.installed || info->tdsx.installed) {
item->color = COLOR_TITLEDB_INSTALLED;
} else {
item->color = COLOR_TITLEDB_NOT_INSTALLED;
}
}
int main(int argc, char **argv)
{
srvInit();
aptInit();
gfxInitDefault();
acInit();
cfguInit();
httpcInit();
ptmuInit();
hidInit();
irrstInit();
aptOpenSession();
Result ret=APT_SetAppCpuTimeLimit(30);
aptCloseSession();
fsInit();
ftp_state = false;
isTopLCDOn = true;
isBottomLCDOn = true;
Handle fileHandle;
u64 size;
u32 bytesRead;
int restore;
// Check user build and enables kernel access
if (nsInit()==0){
CIA_MODE = true;
nsExit();
}else CIA_MODE = false;
isNinjhax2 = false;
if (!hbInit()) khaxInit();
else isNinjhax2 = true;
// Select Audio System (csnd:SND preferred)
if (csndInit() == 0){
csndAccess = true;
csndExit();
}else csndAccess = false;
// Init Audio-Device
int i = 0;
for (i=0;i < 32; i++){
audioChannels[i] = false;
if (!isNinjhax2 && (i < 0x08)) audioChannels[i] = true;
else if (csndAccess && (i < 0x08)) audioChannels[i] = true;
}
// Set main script
char path[256];
if (argc > 0){
int latest_slash = 0;
int i=5;
while (argv[0][i] != '\0'){
if (argv[0][i] == '/') latest_slash = i;
i++;
}
strcpy(path,&argv[0][5]);
path[latest_slash-5] = 0;
strcpy(start_dir,path);
strcpy(cur_dir,path); // Set current dir
strcat(path,"/index.lua");
}else{
strcpy(start_dir,"/");
strcpy(cur_dir,"/"); // Set current dir for GW Mode
strcpy(path,"/index.lua");
}
while(aptMainLoop())
{
restore=0;
char error[2048];
// Load main script
FS_Path filePath=fsMakePath(PATH_ASCII, path);
FS_Archive script=(FS_Archive){ARCHIVE_SDMC, (FS_Path){PATH_EMPTY, 1, (u8*)""}};
Result ret = FSUSER_OpenFileDirectly(&fileHandle, script, filePath, FS_OPEN_READ, 0x00000000);
if (!ret){
FSFILE_GetSize(fileHandle, &size);
buffer = (unsigned char*)(malloc((size+1) * sizeof (char)));
FSFILE_Read(fileHandle, &bytesRead, 0x0, buffer, size);
buffer[size]=0;
FSFILE_Close(fileHandle);
svcCloseHandle(fileHandle);
errMsg = runScript((const char*)buffer, true);
free(buffer);
}else errMsg = "index.lua file not found.";
// Force LCDs power on
if ((!isTopLCDOn) || (!isBottomLCDOn)){
gspLcdInit();
if (!isTopLCDOn) GSPLCD_PowerOnBacklight(GSPLCD_SCREEN_TOP);
if (!isBottomLCDOn) GSPLCD_PowerOnBacklight(GSPLCD_SCREEN_BOTTOM);
gspLcdExit();
isTopLCDOn = true;
isBottomLCDOn = true;
}
// Fake error to force interpreter shutdown
if (strstr(errMsg, "lpp_exit_04")) break;
if (ftp_state) ftp_exit();
ftp_state = false;
int connfd;
while (restore==0){
gspWaitForVBlank();
RefreshScreen();
ClearScreen(0);
ClearScreen(1);
strcpy(error,"Error: ");
strcat(error,errMsg);
if (ftp_state){
u32 ip=(u32)gethostid();
char ip_address[64];
strcat(error,"\n\nPress A to restart\nPress B to exit\nPress Y to enable FTP server\n\nFTP state: ON\nIP: ");
sprintf(ip_address,"%lu.%lu.%lu.%lu", ip & 0xFF, (ip>>8)&0xFF, (ip>>16)&0xFF, (ip>>24)&0xFF);
strcat(error,ip_address);
strcat(error,"\nPort: 5000");
if(connfd<0)connfd=ftp_getConnection();
else{
int ret=ftp_frame(connfd);
if(ret==1) connfd=-1;
}
}else strcat(error,"\n\nPress A to restart\nPress B to exit\nPress Y to enable FTP server\n\nFTP state: OFF");
DebugOutput(error);
hidScanInput();
if(hidKeysDown() & KEY_A){
strcpy(cur_dir,start_dir);
restore=1;
}else if(hidKeysDown() & KEY_B){
restore=2;
}else if(hidKeysDown() & KEY_Y){
if (!ftp_state){
u32 wifiStatus;
if ((u32)ACU_GetWifiStatus(&wifiStatus) != 0xE0A09D2E){
if (wifiStatus != 0){
ftp_init();
connfd = -1;
ftp_state = true;
}
}
}
}
gfxFlushBuffers();
gfxSwapBuffers();
}
if (ftp_state) ftp_exit();
if (isCSND){
if (csndAccess) csndExit();
else ndspExit();
isCSND = false;
}
if (restore==2){
break;
}
}
static Result dumpnand_open_dst(void* data, u32 index, void* initialReadBlock, u32* handle) {
return FSUSER_OpenFileDirectly(handle, ARCHIVE_SDMC, fsMakePath(PATH_EMPTY, ""), fsMakePath(PATH_UTF16, u"/NAND.bin"), FS_OPEN_WRITE | FS_OPEN_CREATE, 0);
}
static int lua_download(lua_State *L){
int argc = lua_gettop(L);
#ifndef SKIP_ERROR_HANDLING
if (argc < 2 || argc > 5) return luaL_error(L, "wrong number of arguments");
#endif
const char* url = luaL_checkstring(L,1);
const char* file = luaL_checkstring(L,2);
const char* headers = (argc >= 3) ? luaL_checkstring(L,3) : NULL;
u8 method = (argc >= 4) ? luaL_checkinteger(L,4) : 0;
const char* postdata = (argc >= 5) ? luaL_checkstring(L,5) : NULL;
httpcContext context;
u32 statuscode=0;
HTTPC_RequestMethod useMethod = HTTPC_METHOD_GET;
if(method <= 3 && method >= 1) useMethod = (HTTPC_RequestMethod)method;
do {
if (statuscode >= 301 && statuscode <= 308) {
char newurl[4096];
httpcGetResponseHeader(&context, (char*)"Location", &newurl[0], 4096);
url = &newurl[0];
httpcCloseContext(&context);
}
Result ret = httpcOpenContext(&context, useMethod, (char*)url, 0);
// Just disable SSL verification instead of loading default certs.
httpcSetSSLOpt(&context, SSLCOPT_DisableVerify);
if(headers != NULL){
char *tokenheader = (char*)malloc(strlen(headers)+1);
strcpy(tokenheader, headers);
char *toker = tokenheader;
char *headername = NULL;
char *headervalue = NULL;
do {
headername = strtok(toker, ":");
if (headername == NULL) break;
headervalue = strtok(NULL, "\n");
if (headervalue == NULL) break;
if (headervalue[0] == ' ') headervalue++;
httpcAddRequestHeaderField(&context, headername, headervalue);
toker = NULL;
} while (headername != NULL && headervalue != NULL);
free(tokenheader);
}
if (useMethod == HTTPC_METHOD_POST && postdata != NULL) {
httpcAddPostDataRaw(&context, (u32*)postdata, strlen(postdata));
}
#ifndef SKIP_ERROR_HANDLING
if(ret==0){
#endif
httpcBeginRequest(&context);
u32 contentsize=0;
httpcGetResponseStatusCode(&context, &statuscode, 0);
if (statuscode == 200){
u32 readSize = 0;
long int bytesWritten = 0;
u8* buf = (u8*)malloc(0x1000);
memset(buf, 0, 0x1000);
Handle fileHandle;
FS_Archive sdmcArchive=(FS_Archive){ARCHIVE_SDMC, (FS_Path){PATH_EMPTY, 1, (u8*)""}};
FS_Path filePath=fsMakePath(PATH_ASCII, file);
FSUSER_OpenFileDirectly( &fileHandle, sdmcArchive, filePath, FS_OPEN_CREATE|FS_OPEN_WRITE, 0x00000000);
do {
ret = httpcDownloadData(&context, buf, 0x1000, &readSize);
FSFILE_Write(fileHandle, NULL, bytesWritten, buf, readSize, 0x10001);
bytesWritten += readSize;
} while (ret == (s32)HTTPC_RESULTCODE_DOWNLOADPENDING);
FSFILE_Close(fileHandle);
svcCloseHandle(fileHandle);
free(buf);
}
#ifndef SKIP_ERROR_HANDLING
}
#endif
} while ((statuscode >= 301 && statuscode <= 303) || (statuscode >= 307 && statuscode <= 308));
#ifndef SKIP_ERROR_HANDLING
if ((statuscode < 200 && statuscode > 226) && statuscode != 304) luaL_error(L, "error opening url");
#endif
httpcCloseContext(&context);
lua_pushinteger(L, statuscode);
return 1;
}
int main()
{
//gfxInitDefault();
sf2d_init();
sf2d_set_clear_color(RGBA8(0x40, 0x40, 0x40, 0xFF));
consoleInit(GFX_TOP, NULL);
Result rc = _srvGetServiceHandle(&romfsRealHandle, "fs:USER");
printf("realHandle: %08lX\n", rc);
rc = FSUSER_Initialize(&romfsRealHandle);
printf("initReal: %08lX\n", rc);
// Regular RomFS
u8 zeros[0xC];
memset(zeros, 0, sizeof(zeros));
FS_archive arch = { ARCH_ROMFS, { PATH_EMPTY, 1, (u8*)"" }, 0, 0 };
FS_path path = { PATH_BINARY, sizeof(zeros), zeros };
Handle romFS_file;
rc = FSUSER_OpenFileDirectly(&romfsRealHandle, &romFS_file, arch, path, FS_OPEN_READ, FS_ATTRIBUTE_NONE);
printf("romfsOpen: %08lX\n", rc);
rc = romfsInitFromFile(romFS_file, 0);
u8 *decomp_out;
u8 *darc_decomp;
u32 decomp_size;
u32 darc_decomp_size;
sf2d_texture **mon;
char *mon_garc;
char *box_garc;
if (rc)
{
printf("romfsInit: %08lX\n", rc);
mon_garc = "sdmc:/1";
box_garc = "sdmc:/3_box";
}
else
{
printf("romfs Init Successful!\n");
mon_garc = "romfs:/a/0/9/3"; //Pokemon X/Y
box_garc = "romfs:/a/1/0/4"; //Pokemon X/Y
u32 num_mon = gnumrecords(mon_garc);
if(!num_mon)
{
mon_garc = "sdmc:/1";
num_mon = gnumrecords(mon_garc);
}
u32 box_test = gnumrecords(box_garc);
if(!box_test)
{
box_garc = "sdmc:/3_box";
}
}
u32 num_mon = gnumrecords(mon_garc);
mon = (sf2d_texture**)malloc(num_mon * sizeof(sf2d_texture*));
printf("Loading sprites...");
int i;
for(i = 0; i < 32; i++)
{
gfread(mon_garc, i, &decomp_out, &decomp_size);
sf2d_texture *mon_sprite = create_texture_from_xy7_clim(decomp_out, decomp_size);
mon[i] = mon_sprite;
free(decomp_out);
}
printf("Pokemon sprites read.\n");
gfread(box_garc, 0, &darc_decomp, &darc_decomp_size);
printf("Box sprites read.\n");
u32 box_clim_size;
u32 box_bg_size;
u32 box_name_size;
void *box_clim;
void *box_bg_clim;
void *box_name;
if(darc_decomp)
{
printf("darc_file: %x\n", box_clim);
}
printf("All read!\n");
sf2d_texture *cursor = load_texture_from_darc(pokedarc_get_darc(darc_decomp), "cursol01.bclim");
sf2d_texture *wallpaper = load_texture_from_darc(pokedarc_get_darc(darc_decomp), "box_wp02.bclim");
sf2d_texture *name_box = load_texture_from_darc(pokedarc_get_darc(darc_decomp), "box_name02.bclim");
sf2d_texture *mode01 = load_texture_from_darc(pokedarc_get_darc(darc_decomp), "mode01.bclim");
sf2d_texture *mode02 = load_texture_from_darc(pokedarc_get_darc(darc_decomp), "mode02.bclim");
sf2d_texture *mode03 = load_texture_from_darc(pokedarc_get_darc(darc_decomp), "mode03.bclim");
sf2d_texture *left_button = load_texture_from_darc(pokedarc_get_darc(darc_decomp), "left_button.bclim");
sf2d_texture *right_button = load_texture_from_darc(pokedarc_get_darc(darc_decomp), "right_button.bclim");
float cursor_spot = 0;
u8 cursor_direction = 1;
float cursor_add = 0.4f;
u8 cursor_mon_x = 3;
u8 cursor_mon_y = 2;
// Main loop
while (aptMainLoop())
{
hidScanInput();
if(cursor_direction)
{
cursor_spot += cursor_add;
if(cursor_spot >= 5.0f)
cursor_direction--;
}
else
{
cursor_spot -= cursor_add;
if(cursor_spot <= 0.0f)
cursor_direction++;
}
sf2d_start_frame(GFX_BOTTOM, GFX_LEFT);
clim_draw_texture(wallpaper, 0, 0);
clim_draw_texture(mode01, 25, 0);
clim_draw_texture(mode02, 25+50+10, 0);
clim_draw_texture(mode03, 25+50+10+50+10, 0);
clim_draw_texture(name_box, 20, 20);
clim_draw_texture(left_button, 5, 20);
clim_draw_texture(right_button, 20+name_box->width, 20);
int x, y;
int i = 1;
for(y = 0; y < 5; y++)
{
for(x = 0; x < 6; x++)
{
clim_draw_texture(mon[i], 10+(x*32), 45+(y*30));
i++;
}
}
clim_draw_texture(cursor, (int)(10-5+((cursor_mon_x + 1) * 32)-cursor_spot), (int)(45+5+((cursor_mon_y - 1) * 30)+cursor_spot));
sf2d_end_frame();
u32 kDown = hidKeysDown();
if (kDown & KEY_START)
break; // break in order to return to hbmenu
sf2d_swapbuffers();
}
sf2d_fini();
romfsExit();
gfxExit();
return 0;
}
unsigned char loadROM(char *filename) {
char name[17];
enum romType type;
int romSize;
int ramSize;
int i;
#ifdef DS3
u64 length;
u32 bytesRead;
FS_archive sdmcArchive = (FS_archive){ARCH_SDMC, (FS_path){PATH_EMPTY, 1, (u8*)""}};
FS_path filePath = FS_makePath(PATH_CHAR, filename); // /filename
Result ret = FSUSER_OpenFileDirectly(NULL, &fileHandle, sdmcArchive, filePath, FS_OPEN_READ, FS_ATTRIBUTE_NONE);
if(ret) return false;
ret = FSFILE_GetSize(fileHandle, &length);
if(ret) return false;
ret = FSFILE_Read(fileHandle, &bytesRead, 0x0, cart, length);
if(ret || length != bytesRead) return false;
memset(name, '\0', 17);
for(i = 0; i < 16; i++) {
if(cart[i + ROM_OFFSET_NAME] == 0x80 || cart[i + ROM_OFFSET_NAME] == 0xc0) name[i] = '\0';
else name[i] = cart[i + ROM_OFFSET_NAME];
}
printf("Internal ROM name: %s\n", name);
type = cart[ROM_OFFSET_TYPE];
if(!romTypeString[type]) {
printf("Unknown ROM type: %#02x\n", type);
return false;
}
printf("ROM type: %s\n", romTypeString[type]);
if(type != ROM_PLAIN) {
printf("Only 32KB games with no mappers are supported!\n");
return false;
}
romSize = cart[ROM_OFFSET_ROM_SIZE];
if((romSize & 0xF0) == 0x50) romSize = (int)pow(2.0, (double)(((0x52) & 0xF) + 1)) + 64;
else romSize = (int)pow(2.0, (double)(romSize + 1));
printf("ROM size: %dKB\n", romSize * 16);
if(romSize * 16 != 32) {
printf("Only 32KB games with no mappers are supported!\n");
return false;
}
if(length != romSize * 16 * 1024) {
printf("ROM filesize does not equal ROM size!\n");
return false;
}
ramSize = cart[ROM_OFFSET_RAM_SIZE];
ramSize = (int)pow(4.0, (double)ramSize) / 2;
printf("RAM size: %dKB\n", ramSize);
ramSize = ceil(ramSize / 8.0f);
ret = FSFILE_Close(fileHandle);
if(ret) return false;
return 1;
#else
#ifdef PS4
void ps4loadROM(void);
ps4loadROM();
return 1;
#else
FILE *f;
size_t length;
unsigned char header[0x180];
f = fopen(filename, "rb");
if(!f) return 0;
fseek(f, 0, SEEK_END);
length = ftell(f);
if(length < 0x180) {
printf("ROM is too small!\n");
fclose(f);
return 0;
}
rewind(f);
fread(header, 0x180, 1, f);
memset(name, '\0', 17);
for(i = 0; i < 16; i++) {
if(header[i + ROM_OFFSET_NAME] == 0x80 || header[i + ROM_OFFSET_NAME] == 0xc0) name[i] = '\0';
else name[i] = header[i + ROM_OFFSET_NAME];
}
printf("Internal ROM name: %s\n", name);
type = header[ROM_OFFSET_TYPE];
if(!romTypeString[type]) {
printf("Unknown ROM type: %#02x\n", type);
fclose(f);
return 0;
}
printf("ROM type: %s\n", romTypeString[type]);
if(type != ROM_PLAIN) {
printf("Only 32KB games with no mappers are supported!\n");
fclose(f);
return 0;
}
romSize = header[ROM_OFFSET_ROM_SIZE];
#ifndef PSP
if((romSize & 0xF0) == 0x50) romSize = (int)pow(2.0, (double)(((0x52) & 0xF) + 1)) + 64;
else romSize = (int)pow(2.0, (double)(romSize + 1));
#else
// PSP doesn't support pow...
romSize = 2;
#endif
printf("ROM size: %dKB\n", romSize * 16);
if(romSize * 16 != 32) {
printf("Only 32KB games with no mappers are supported!\n");
fclose(f);
return 0;
}
if(length != romSize * 16 * 1024) {
printf("ROM filesize does not equal ROM size!\n");
//fclose(f);
//return 0;
}
ramSize = header[ROM_OFFSET_RAM_SIZE];
#ifndef PSP
ramSize = (int)pow(4.0, (double)(ramSize)) / 2;
#else
// PSP doesn't support pow...
ramSize = 0;
#endif
printf("RAM size: %dKB\n", ramSize);
ramSize = ceil(ramSize / 8.0f);
/*cart = malloc(length);
if(!cart) {
printf("Could not allocate memory!\n");
fclose(f);
return 0;
}*/
rewind(f);
fread(cart, length, 1, f);
fclose(f);
return 1;
#endif
#endif
}
static Result dumpnand_open_src(void* data, u32 index, u32* handle) {
return FSUSER_OpenFileDirectly(handle, ARCHIVE_NAND_W_FS, fsMakePath(PATH_EMPTY, ""), fsMakePath(PATH_UTF16, u"/"), FS_OPEN_READ, 0);
}
Result doRegionFive(u8* code_data, u32 code_size, char* cfg_path)
{
u8 region_code = 2;
u8 language_code = 2;
u8 clock = 0;
u8 nim = 0;
int nimversion = -1;
char* romfs = NULL;
char* code = NULL;
Result ret = configureTitle(cfg_path, ®ion_code, &language_code, &clock, &romfs, &code, &nim, &nimversion);
if(ret)return ret;
u64 tid = 0;
getTitleInformation(NULL, &tid);
if(code)
{
char path[32];
sprintf(path, "sdmc:%s", code);
FILE* f = fopen(path, "rb");
if(!f)return -1;
fread(code_data, 1, code_size, f);
fclose(f);
}
printf("region %X\n", region_code);
printf("language %X\n", language_code);
if(nimversion >= 0)
{
patchNimTitleVersion(code_data, code_size, nimversion);
}
if(region_code != 0xFF)
{
function_s cfgSecureInfoGetRegion = findCfgSecureInfoGetRegion(code_data, code_size);
printf("cfgSecureInfoGetRegion : %08X - %08X\n", (unsigned int)(cfgSecureInfoGetRegion.start * 4 + 0x00100000), (unsigned int)(cfgSecureInfoGetRegion.end * 4 + 0x00100000));
patchCfgSecureInfoGetRegion(code_data, code_size, cfgSecureInfoGetRegion, region_code);
}
if(language_code != 0xFF)
{
function_s cfgCtrGetLanguage = findCfgCtrGetLanguage(code_data, code_size);
printf("cfgCtrGetLanguage : %08X - %08X\n", (unsigned int)(cfgCtrGetLanguage.start * 4 + 0x00100000), (unsigned int)(cfgCtrGetLanguage.end * 4 + 0x00100000));
patchCfgCtrGetLanguage(code_data, code_size, cfgCtrGetLanguage, language_code);
}
if(clock != 0xFF)
{
setClockrate(clock);
}
if(nim)
{
patchNimCheckSysupdateAvailableSOAP(code_data, code_size);
const static char target[] = "%s/samurai/ws/%s/title/%llu/other_purchased?shop_id=1&lang=%s&_t";
const static char url[] = "http://smealum.github.io/ninjhax2/samurai.json?%s%s%llu%s";
int i;
int cursor = 0;
int l = strlen(target);
for(i=0; i<code_size; i++)
{
if(cursor == l)
{
strcpy((char*)&code_data[i - l], url);
break;
}
if(target[cursor] == code_data[i]) cursor++;
else cursor = 0;
}
}
if(romfs)
{
Handle fsHandle, fileHandle;
FS_archive sdmcArchive = (FS_archive){0x00000009, (FS_path){PATH_EMPTY, 1, (u8*)""}};
srvGetServiceHandle(&fsHandle, "fs:USER");
FSUSER_OpenFileDirectly(&fsHandle, &fileHandle, sdmcArchive, FS_makePath(PATH_CHAR, romfs), FS_OPEN_READ, FS_ATTRIBUTE_NONE);
// patchFsOpenRom(code_data, code_size, fsHandle, romfs);
patchFsOpenRom(code_data, code_size, fileHandle);
}
// {
// Handle fsHandle;
// FS_archive sdmcArchive = (FS_archive){0x00000009, (FS_path){PATH_EMPTY, 1, (u8*)""}};
// srvGetServiceHandle(&fsHandle, "fs:USER");
// FSUSER_OpenArchive(&fsHandle, &sdmcArchive);
// patchFsSavegame(code_data, code_size, fsHandle, (u64)sdmcArchive.handleLow | (((u64)sdmcArchive.handleHigh) << 32));
// }
return 0;
}
