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;
}
Result getFile(u8 ** buffer, u64 * size) {
Result ret = 0;
Handle filehandle = 0;
u32 tmpval = 0;
ret = FSUSER_OpenFile(&filehandle, extdata_archive, verListPath,
FS_OPEN_READ, 0);
if (ret != 0)
return ret;
ret = FSFILE_GetSize(filehandle, size);
if (ret != 0)
return ret;
if (*size <= ENTRY_SIZE) {
*size = 0;
return ret;
}
if (mode == MODE_ALL)
*size = ENTRY_SIZE;
*buffer = malloc(*size);
ret = FSFILE_Read(filehandle, &tmpval, 0, *buffer, *size);
if (ret != 0)
return ret;
FSFILE_Close(filehandle);
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;
}
bool _vf3dClose(struct VFile* vf) {
struct VFile3DS* vf3d = (struct VFile3DS*) vf;
FSFILE_Close(vf3d->handle);
svcCloseHandle(vf3d->handle);
return true;
}
Result FS_WriteFile(const char* path, const void* src, u64 size, FS_Archive archive, u32* bytesWritten)
{
if (!path || !src || !archive || !bytesWritten) return -1;
Result ret;
Handle fileHandle;
debug_print("FS_WriteFile:\n");
ret = FSUSER_OpenFile(&fileHandle, archive, fsMakePath(PATH_ASCII, path), FS_OPEN_WRITE | FS_OPEN_CREATE, FS_ATTRIBUTE_NONE);
r(" > FSUSER_OpenFile: %lx\n", ret);
if (R_FAILED(ret)) return ret;
if (R_SUCCEEDED(ret))
{
ret = FSFILE_Write(fileHandle, bytesWritten, 0L, src, size, FS_WRITE_FLUSH);
r(" > FSFILE_Write: %lx\n", ret);
if (R_FAILED(ret) || *bytesWritten != size) ret = -2;
}
FSFILE_Close(fileHandle);
r(" > FSFILE_Close\n");
return ret;
}
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 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;
}
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 Result action_paste_files_open_dst(void* data, u32 index, void* initialReadBlock, u64 size, u32* handle) {
paste_files_data* pasteData = (paste_files_data*) data;
Result res = 0;
char dstPath[FILE_PATH_MAX];
action_paste_files_get_dst_path(pasteData, index, dstPath);
FS_Path* fsPath = util_make_path_utf8(dstPath);
if(fsPath != NULL) {
Handle currHandle;
pasteData->currExists = R_SUCCEEDED(FSUSER_OpenFile(&currHandle, pasteData->target->archive, *fsPath, FS_OPEN_READ, 0));
if(pasteData->currExists) {
FSFILE_Close(currHandle);
} else {
res = FSUSER_CreateFile(pasteData->target->archive, *fsPath, 0, size);
}
if(R_SUCCEEDED(res)) {
res = FSUSER_OpenFile(handle, pasteData->target->archive, *fsPath, FS_OPEN_WRITE, 0);
}
util_free_path_utf8(fsPath);
} else {
res = R_FBI_OUT_OF_MEMORY;
}
return res;
}
Result write_savedata(char* path, u8* data, u32 size)
{
if(!path || !data || !size)return -1;
Handle outFileHandle;
u32 bytesWritten;
Result ret = 0;
int fail = 0;
ret = FSUSER_OpenFile(&saveGameFsHandle, &outFileHandle, saveGameArchive, FS_makePath(PATH_CHAR, path), FS_OPEN_CREATE | FS_OPEN_WRITE, FS_ATTRIBUTE_NONE);
if(ret){fail = -8; goto writeFail;}
ret = FSFILE_Write(outFileHandle, &bytesWritten, 0x0, data, size, 0x10001);
if(ret){fail = -9; goto writeFail;}
ret = FSFILE_Close(outFileHandle);
if(ret){fail = -10; goto writeFail;}
ret = FSUSER_ControlArchive(saveGameFsHandle, saveGameArchive);
writeFail:
if(fail)sprintf(status, "Failed to write to file: %d\n %08X %08X", fail, (unsigned int)ret, (unsigned int)bytesWritten);
else sprintf(status, "Successfully wrote to file!\n %08X ", (unsigned int)bytesWritten);
return ret;
}
static Result action_paste_files_close_dst(void* data, u32 index, bool succeeded, u32 handle) {
paste_files_data* pasteData = (paste_files_data*) data;
Result res = 0;
if(R_SUCCEEDED(res = FSFILE_Close(handle))) {
char dstPath[FILE_PATH_MAX];
action_paste_files_get_dst_path(pasteData, index, dstPath);
char parentPath[FILE_PATH_MAX];
util_get_parent_path(parentPath, dstPath, FILE_PATH_MAX);
char baseDstPath[FILE_PATH_MAX];
if(pasteData->target->attributes & FS_ATTRIBUTE_DIRECTORY) {
strncpy(baseDstPath, pasteData->target->path, FILE_PATH_MAX);
} else {
util_get_parent_path(baseDstPath, pasteData->target->path, FILE_PATH_MAX);
}
if(strncmp(parentPath, baseDstPath, FILE_PATH_MAX) == 0) {
list_item* dstItem = NULL;
if(R_SUCCEEDED(task_create_file_item(&dstItem, pasteData->target->archive, dstPath, ((file_info*) ((list_item*) linked_list_get(&pasteData->contents, index))->data)->attributes & ~FS_ATTRIBUTE_READ_ONLY))) {
linked_list_add(pasteData->items, dstItem);
}
}
}
return res;
}
// ==================================================
Result FS_loadFile(char* path, void* dst, FS_archive* fsArchive, Handle* fsHandle, u64 maxSize, u32* bytesRead)
// --------------------------------------------------
{
if (!path || !dst || !fsArchive) return -1;
Result ret = 0;
u64 size;
Handle fileHandle;
if (!ret)
{
ret = FSUSER_OpenFile(fsHandle, &fileHandle, *fsArchive, FS_makePath(PATH_CHAR, path), FS_OPEN_READ, FS_ATTRIBUTE_NONE);
if (ret) return ret;
}
if (!ret)
{
ret = FSFILE_GetSize(fileHandle, &size);
if (ret || size > maxSize) ret = -2;
}
if (!ret)
{
ret = FSFILE_Read(fileHandle, bytesRead, 0, dst, size);
if (ret || *bytesRead < size) ret=-3;
}
FSFILE_Close(fileHandle);
return ret;
}
Result archive_getfilesize(Archive archive, char *path, u32 *outsize)
{
Result ret=0;
struct stat filestats;
u64 tmp64=0;
Handle filehandle=0;
char filepath[256];
if(archive==SDArchive)
{
memset(filepath, 0, 256);
strncpy(filepath, path, 255);
if(stat(filepath, &filestats)==-1)return errno;
*outsize = filestats.st_size;
return 0;
}
ret = FSUSER_OpenFile(NULL, &filehandle, extdata_archive, FS_makePath(PATH_CHAR, path), 1, 0);
if(ret!=0)return ret;
ret = FSFILE_GetSize(filehandle, &tmp64);
if(ret==0)*outsize = (u32)tmp64;
FSFILE_Close(filehandle);
return ret;
}
Result FS_ReadFile(const char* path, void* dst, u64 maxSize, FS_Archive archive, u32* bytesRead)
{
if (!path || !dst || !archive || !bytesRead) return -1;
Result ret;
u64 size;
Handle fileHandle;
debug_print("FS_ReadFile:\n");
ret = FSUSER_OpenFile(&fileHandle, archive, fsMakePath(PATH_ASCII, path), FS_OPEN_READ, FS_ATTRIBUTE_NONE);
r(" > FSUSER_OpenFile: %lx\n", ret);
if (R_FAILED(ret)) return ret;
ret = FSFILE_GetSize(fileHandle, &size);
r(" > FSFILE_GetSize: %lx\n", ret);
if (R_FAILED(ret) || size > maxSize) ret = -2;
if (R_SUCCEEDED(ret))
{
ret = FSFILE_Read(fileHandle, bytesRead, 0x0, dst, size);
r(" > FSFILE_Read: %lx\n", ret);
if (R_FAILED(ret) || *bytesRead < size) ret = -3;
}
FSFILE_Close(fileHandle);
r(" > FSFILE_Close\n");
return ret;
}
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");
}
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;
}
Result write_savedata(const char* path, const void* data, size_t size)
{
if(!path || !data || size == 0) return -1;
Result ret = -1;
int fail = 0;
fsUseSession(save_session);
ret = FSUSER_OpenArchive(&save_archive, ARCHIVE_SAVEDATA, (FS_Path){PATH_EMPTY, 1, (u8*)""});
if(R_FAILED(ret))
{
fail = -1;
goto writeFail;
}
// delete file
FSUSER_DeleteFile(save_archive, fsMakePath(PATH_ASCII, path));
FSUSER_ControlArchive(save_archive, ARCHIVE_ACTION_COMMIT_SAVE_DATA, NULL, 0, NULL, 0);
Handle file = 0;
ret = FSUSER_OpenFile(&file, save_archive, fsMakePath(PATH_ASCII, path), FS_OPEN_CREATE | FS_OPEN_WRITE, 0);
if(R_FAILED(ret))
{
fail = -2;
goto writeFail;
}
u32 bytes_written = 0;
ret = FSFILE_Write(file, &bytes_written, 0, data, size, FS_WRITE_FLUSH | FS_WRITE_UPDATE_TIME);
if(R_FAILED(ret))
{
fail = -3;
goto writeFail;
}
ret = FSFILE_Close(file);
if(R_FAILED(ret))
{
fail = -4;
goto writeFail;
}
ret = FSUSER_ControlArchive(save_archive, ARCHIVE_ACTION_COMMIT_SAVE_DATA, NULL, 0, NULL, 0);
if(R_FAILED(ret)) fail = -5;
writeFail:
FSUSER_CloseArchive(save_archive);
fsEndUseSession();
if(fail) sprintf(status, "Failed to write to file: %d\n %08lX %08lX", fail, ret, bytes_written);
else sprintf(status, "Successfully wrote to file!\n %08lX ", bytes_written);
return ret;
}
int saveBitmap(const char* filename, u8* buffer, u32 w, u32 h)
{
u8* temp=(u8*)malloc(w*h*3+sizeof(INFOHEADER)+sizeof(HEADER));
HEADER* header=(HEADER*)temp;
INFOHEADER* infoheader=(INFOHEADER*)(temp+sizeof(HEADER));
write16(&header->type, 0x4D42);
write32(&header->size, w*h*3+sizeof(INFOHEADER)+sizeof(HEADER));
write32(&header->offset, sizeof(INFOHEADER)+sizeof(HEADER));
write16(&header->reserved1, 0);
write16(&header->reserved2, 0);
write16(&infoheader->bits, 24);
write32(&infoheader->size, sizeof(INFOHEADER));
write32(&infoheader->compression, 0);
write32(&infoheader->width, w);
write32(&infoheader->height, h);
write16(&infoheader->planes, 1);
write32(&infoheader->imagesize, w*h*3);
write32(&infoheader->xresolution, 0);
write32(&infoheader->yresolution, 0);
write32(&infoheader->importantcolours, 0);
write32(&infoheader->ncolours, 0);
int y,x;
for(y=0;y<h;y++)
{
for(x=0;x<w;x++)
{
temp[((y*w)+x)*3+sizeof(INFOHEADER)+sizeof(HEADER)]=buffer[(x*h+y)*3+0];
temp[((y*w)+x)*3+1+sizeof(INFOHEADER)+sizeof(HEADER)]=buffer[(x*h+y)*3+1];
temp[((y*w)+x)*3+2+sizeof(INFOHEADER)+sizeof(HEADER)]=buffer[(x*h+y)*3+2];
}
}
Handle file;
Result ret=FSUSER_OpenFile(NULL, &file, configuration.sdmc, FS_makePath(PATH_CHAR, filename), FS_OPEN_WRITE|FS_OPEN_CREATE, FS_ATTRIBUTE_NONE);
if(ret){svcCloseHandle(file); return -2;}
u32 size=w*h*3+sizeof(INFOHEADER)+sizeof(HEADER);
u32 bytesWritten=0;
ret=FSFILE_Write(file, &bytesWritten, 0, temp, size, FS_WRITE_FLUSH);
if(ret || bytesWritten!=size)return -2;
FSFILE_Close(file);
svcCloseHandle(file);
free(temp);
return 0;
}
void getNextScreenshotCnt()
{
//open files while incrementing screenshotCnt until file doesn't exist
static char path[256];
Result ret=0;
while(!ret && screenshotCnt<MAX_SCREENSHOTS)
{
screenshotCnt++;
snprintf(path, 256, "%s/scr_%d_left.bmp", configuration.path, screenshotCnt);
Handle file;
ret=FSUSER_OpenFile(NULL, &file, configuration.sdmc, FS_makePath(PATH_CHAR, path), FS_OPEN_READ, FS_ATTRIBUTE_NONE);
FSFILE_Close(file);
svcCloseHandle(file);
}
}
bool fileExists(char *path) {
if (!path)return false;
Result ret;
Handle fileHandle;
ret = FSUSER_OpenFile(NULL, &fileHandle, sdmcArchive, FS_makePath(PATH_CHAR, path),
FS_OPEN_READ, FS_ATTRIBUTE_NONE);
if (ret != 0)return false;
ret = FSFILE_Close(fileHandle);
if (ret != 0)return false;
return true;
}
static int lua_unloadBMPV(lua_State *L){
int argc = lua_gettop(L);
if (argc != 1) return luaL_error(L, "wrong number of arguments");
BMPV* src = (BMPV*)luaL_checkint(L, 1);
if (src->samplerate != 0 && src->audio_size != 0 && !GW_MODE){
linearFree(src->audiobuf);
if (src->audiotype == 2){
linearFree(src->audiobuf2);
}
}
FSFILE_Close(src->sourceFile);
svcCloseHandle(src->sourceFile);
free(src->framebuf);
free(src);
return 0;
}
/*! Close an open file
*
* @param[in,out] r newlib reentrancy struct
* @param[in] fd Pointer to sdmc_file_t
*
* @returns 0 for success
* @returns -1 for error
*/
static int
sdmc_close(struct _reent *r,
int fd)
{
Result rc;
/* get pointer to our data */
sdmc_file_t *file = (sdmc_file_t*)fd;
rc = FSFILE_Close(file->fd);
if(rc == 0)
return 0;
r->_errno = rc;
return -1;
}
void dbg_save(char* path, void* buf, int size)
{
Handle sram;
FS_path sramPath;
sramPath.type = PATH_CHAR;
sramPath.size = strlen(path) + 1;
sramPath.data = (u8*)path;
Result res = FSUSER_OpenFile(NULL, &sram, sdmcArchive, sramPath, FS_OPEN_CREATE|FS_OPEN_WRITE, FS_ATTRIBUTE_NONE);
if ((res & 0xFFFC03FF) == 0)
{
u32 byteswritten = 0;
FSFILE_Write(sram, &byteswritten, 0, (u32*)buf, size, 0x10001);
FSFILE_Close(sram);
}
}
/*! Close an open file
*
* @param[in,out] r newlib reentrancy struct
* @param[in] fd Pointer to sdmc_file_t
*
* @returns 0 for success
* @returns -1 for error
*/
static int
sdmc_close(struct _reent *r,
void *fd)
{
Result rc;
/* get pointer to our data */
sdmc_file_t *file = (sdmc_file_t*)fd;
rc = FSFILE_Close(file->fd);
if(R_SUCCEEDED(rc))
return 0;
r->_errno = sdmc_translate_error(rc);
return -1;
}
// ==================================================
Result FS_saveFile(char* path, void* src, u64 size, FS_archive* fsArchive, Handle* fsHandle, u32* bytesWritten)
// --------------------------------------------------
{
if (!path || !src || !fsArchive) return -1;
Result ret;
Handle fileHandle;
ret = FSUSER_OpenFile(fsHandle, &fileHandle, *fsArchive, FS_makePath(PATH_CHAR, path), FS_OPEN_WRITE | FS_OPEN_CREATE, FS_ATTRIBUTE_NONE);
if (ret) return ret;
ret = FSFILE_Write(fileHandle, bytesWritten, 0, src, size, FS_WRITE_NOFLUSH);
if (ret) return ret;
FSFILE_Close(fileHandle);
return ret;
}
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;
}
Result archive_writefile(Archive archive, char *path, u8 *buffer, u32 size)
{
Result ret=0;
Handle filehandle=0;
u32 tmpval=0;
FILE *f;
char filepath[256];
if(archive==SDArchive)
{
memset(filepath, 0, 256);
strncpy(filepath, path, 255);
f = fopen(filepath, "w+");
if(f==NULL)return errno;
tmpval = fwrite(buffer, 1, size, f);
fclose(f);
if(tmpval!=size)return -2;
return 0;
}
FS_path fspath = FS_makePath(PATH_CHAR, path);
ret = FSUSER_DeleteFile(NULL, extdata_archive, fspath);
ret = FSUSER_CreateFile(NULL, extdata_archive, fspath, size);
if(ret!=0)return ret;
ret = FSUSER_OpenFile(NULL, &filehandle, extdata_archive, fspath, FS_OPEN_WRITE, 0);
if(ret!=0)return ret;
ret = FSFILE_Write(filehandle, &tmpval, 0, buffer, size, FS_WRITE_FLUSH);
FSFILE_Close(filehandle);
if(ret==0 && tmpval!=size)ret=-2;
return ret;
}
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;
}
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;
}