// ==================================================
Result FS_filesysInit(Handle* sdHandle, Handle* saveHandle, FS_archive* sdArchive, FS_archive* saveArchive)
// --------------------------------------------------
{
Result ret;
printf(" Getting SD Card handle\n");
ret = srvGetServiceHandle(sdHandle, "fs:USER");
if (ret) return ret;
printf(" Opening SD Card archive\n");
*sdArchive = (FS_archive){0x9, (FS_path){PATH_EMPTY, 1, (u8*)""}, 0, 0};
ret = FSUSER_OpenArchive(sdHandle, sdArchive);
if (ret) return ret;
printf(" Getting save handle\n");
ret = _srvGetServiceHandle(saveHandle, "fs:USER");
if (ret) return ret;
printf(" Initializing save handle\n");
ret = FSUSER_Initialize(saveHandle);
if (ret) return ret;
printf(" Opening save archive\n");
*saveArchive = (FS_archive){0x4, (FS_path){PATH_EMPTY, 0, NULL}, 0, 0};
ret = FSUSER_OpenArchive(saveHandle, saveArchive);
return ret;
}
Result FSCIA_Init(u64 titleid, FS_MediaType mediatype)
{
Result ret = 1;
debug_print("FSCIA_Init:\n");
if (!saveInitialized)
{
lowPath[0] = mediatype;
lowPath[1] = titleid; /// titleid & 0xFFFFFFFF
lowPath[2] = titleid >> 32; // (titleid >> 32) & 0xFFFFFFFF
debug_print(" > [0]: 0x%016lx\n", lowPath[0]);
debug_print(" > [1]: 0x%016lx\n", lowPath[1]);
debug_print(" > [2]: 0x%016lx\n", lowPath[2]);
ret = FSUSER_OpenArchive(&saveArchive, ARCHIVE_USER_SAVEDATA, (FS_Path) { PATH_BINARY, 12, lowPath });
r(" > FSUSER_OpenArchive: %lx\n", ret);
saveInitialized = R_SUCCEEDED(ret); // true
if (!saveInitialized)
{
ret = FSUSER_OpenArchive(&saveArchive, ARCHIVE_SDMC, fsMakePath(PATH_EMPTY, NULL));
r(" > FSUSER_OpenArchive: %lx\n", ret);
saveInitialized = R_SUCCEEDED(ret); // true
}
}
//All the information used here was found on 3dbrew.org
//thank them too.
bool openSaveArch(FS_Archive *out, const titleData dat, bool showError)
{
//binary path
u32 path[3];
//first is mediaType
path[0] = dat.media;
//low id
path[1] = dat.low;
//high id. this is usually 0x00040000
path[2] = dat.high;
//setup archive info
Handle fs;
*out = (FS_Archive){ARCHIVE_USER_SAVEDATA, (FS_Path){PATH_BINARY, 12, path}};
Result res = FSUSER_OpenArchive(out);
if(res)
{
if(showError)
showMessage("Error opening save archive!");
logWriteError("Error opening save archive", res);
return false;
}
return true;
}
void NES_LOADROMLIST() {
Handle romHandle;
FS_dirent dirStruct;
FS_path dirPath = FS_makePath(PATH_CHAR, "/3DNES/ROMS");
// init SDMC archive
sdmcArchive = (FS_archive){0x9, (FS_path){PATH_EMPTY, 1, (u8*)""}};
FSUSER_OpenArchive(NULL, &sdmcArchive);
FSUSER_OpenDirectory(NULL, &romHandle, sdmcArchive, dirPath);
// Get number of files in directory
fileSystem.totalFiles = 0
while(1) {
u32 dataRead = 0;
FSDIR_Read(romHandle, &dataRead, 1, &dirStruct);
if(dataRead == 0) break;
fileSystem.totalFiles++;
}
fileSystem.fileList = linearAlloc(MAX_FILENAME_SIZE * fileSystem.totalFiles);
FSUSER_OpenDirectory(NULL, &romHandle, sdmcArchive, dirPath);
fileSystem.totalFiles = 0;
while(1) {
u32 dataRead = 0;
FSDIR_Read(romHandle, &dataRead, 1, &dirStruct);
if(dataRead == 0) break;
unicodeToChar(&fileSystem.fileList[MAX_FILENAME_SIZE * fileSystem.totalFiles), dirStruct.name);
fileSystem.totalFiles++;
}
FSDIR_Close(romHandle);
}
bool arnMigrate() {
const static FS_Path aurei = fsMakePath(PATH_ASCII, "/aurei");
const static FS_Path luma = fsMakePath(PATH_ASCII, "/luma");
FS_Archive sdmcArchive = { 0x00000009,{ PATH_EMPTY, 1, (u8*) "" } };
if (FSUSER_OpenArchive(&sdmcArchive) != 0) {
std::printf("\nCould not access SD Card (?)\n\n");
return false;
}
// Check if /luma already existsHandle directory = { 0 };
if (FSUSER_OpenDirectory(NULL, sdmcArchive, luma) == 0) {
std::printf("Luma directory already exists, skipping migration..\n");
return true;
}
if (!renameRecursive(sdmcArchive, "/aurei", "/luma")) {
FSUSER_CloseArchive(&sdmcArchive);
return false;
}
// Delete the source directory and check if it succeeds
Result res = FSUSER_DeleteDirectoryRecursively(sdmcArchive, aurei);
if (res != 0) {
std::printf("\nWARN: Could not delete original /aurei (%ld)!\n\n", res);
}
FSUSER_CloseArchive(&sdmcArchive);
return true;
}
Result backupByConfig(u8 *filebuffer, size_t bufsize) {
memset(filebuffer, 0, bufsize);
FILE *configfile = fopen("config.txt", "r");
if (configfile==NULL) return errno;
char source_path[1000], sd_destination[1000];
u32 source_archive;
mediatypes_enum mtype;
FS_archiveIds atype;
int buf2size = 0x10000;
u8 *buf2 = malloc(buf2size);
if (buf2==NULL)
{
printf("malloc failed\n");
gfxFlushBuffers();
gfxSwapBuffers();
return -1;
}
memset(buf2, 0, buf2size);
while (fgets((char*) buf2, buf2size, configfile) != NULL) {
if (sscanf((const char*) buf2, "DUMP \"%x:%999[^\"]\" \"%999[^\"]\"", (unsigned int*) &source_archive, source_path, sd_destination) == 3) {
if (source_archive >= 0x80000000) {
mtype = mediatype_NAND;
atype = ARCH_SHARED_EXTDATA;
}
else {
mtype = mediatype_SDMC;
atype = ARCH_EXTDATA;
}
u32 extdata_archive_lowpathdata[3] = {mtype, source_archive, 0};
extdata_archive = (FS_archive){atype, (FS_path){PATH_BINARY, 0xC, (u8*)extdata_archive_lowpathdata}};
Result ret = FSUSER_OpenArchive(NULL, &extdata_archive);
if(ret!=0)
{
printf("could not open archive\n");
gfxFlushBuffers();
gfxSwapBuffers();
continue;
}
printf("Dumping from %s\n", source_path);
gfxFlushBuffers();
gfxSwapBuffers();
ret = archive_copyfile(Extdata_Archive, SDArchive, source_path, sd_destination, filebuffer, 0, bufsize, source_path);
if (ret) {
printf("Copying failed!\n");
} else {
printf("Success.\n");
}
gfxFlushBuffers();
gfxSwapBuffers();
FSUSER_CloseArchive(NULL, &extdata_archive);
}
}
free(buf2);
fclose(configfile);
return 0;
}
/*! Initialize SDMC device */
Result sdmcInit(void)
{
Result rc;
rc = FSUSER_OpenArchive(NULL, &sdmcArchive);
if(rc == 0)
{
int dev = AddDevice(&sdmc_devoptab);
if (__system_argc != 0 && __system_argv[0] != NULL)
{
if (FindDevice(__system_argv[0]) == dev)
{
strncpy(__fixedpath,__system_argv[0],PATH_MAX);
char *last_slash = strrchr(__fixedpath,'/');
if (last_slash != NULL) {
last_slash[0] = 0;
chdir(__fixedpath);
}
}
}
}
return rc;
}
Result filesystemInit()
{
Result ret;
fsInit();
if (R_FAILED(ret = srvGetServiceHandleDirect(&fsHandle, "fs:USER"))) return ret;
if (R_FAILED(ret = FSUSER_Initialize(fsHandle))) return ret;
fsUseSession(fsHandle, false);
sdmcArchive = (FS_Archive){ARCHIVE_SDMC, (FS_Path){PATH_EMPTY, 1, (u8*)""}, 0};
if (R_FAILED(ret = FSUSER_OpenArchive(&sdmcArchive))) return ret;
saveGameArchive = (FS_Archive){ARCHIVE_SAVEDATA, (FS_Path){PATH_EMPTY, 1, (u8*)""}, 0};
if (R_FAILED(ret = FSUSER_OpenArchive(&saveGameArchive))) return ret;
return ret;
}
Result restoreFromSd(u8 *buf, size_t bufsize) {
memset(buf, 0, bufsize);
FILE *configfile = fopen("config.txt", "r");
if (configfile==NULL) return errno;
char sd_source[1000], destination_path[1000];
u32 destination_archive;
mediatypes_enum mtype;
FS_archiveIds atype;
u8 *filebuffer2 = malloc(bufsize);
memset(filebuffer2, 0, bufsize);
while (fgets((char*) buf, bufsize, configfile) != NULL) {
if (sscanf((const char*) buf, "RESTORE \"%999[^\"]\" \"%x:%999[^\"]\"", sd_source, (unsigned int*) &destination_archive, destination_path) == 3) {
if (destination_archive >= 0x80000000) {
mtype = mediatype_NAND;
atype = ARCH_SHARED_EXTDATA;
}
else {
mtype = mediatype_SDMC;
atype = ARCH_EXTDATA;
}
u32 extdata_archive_lowpathdata[3] = {mtype, destination_archive, 0};
extdata_archive = (FS_archive) {
atype, (FS_path) {
PATH_BINARY, 0xC, (u8*)extdata_archive_lowpathdata
}
};
Result ret = FSUSER_OpenArchive(NULL, &extdata_archive);
if(ret!=0)
{
printf("could not open archive\n");
gfxFlushBuffers();
gfxSwapBuffers();
continue;
}
printf("Restoring to %s\n", destination_path);
gfxFlushBuffers();
gfxSwapBuffers();
ret = archive_copyfile(SDArchive, Extdata_Archive, sd_source, destination_path, filebuffer2, 0, bufsize, destination_path);
if (ret) {
printf("Copying failed!\n");
} else {
printf("Success.\n");
}
gfxFlushBuffers();
gfxSwapBuffers();
FSUSER_CloseArchive(NULL, &extdata_archive);
}
}
free(filebuffer2);
fclose(configfile);
return 0;
}
// Opens the SD card so files can be opened from it.
int sdmcArchiveInit() {
Result response;
sdmcArchive = (FS_Archive) {ARCHIVE_SDMC, (FS_Path) {PATH_EMPTY, 1, (u8 *) ""}};
if(R_FAILED(response = FSUSER_OpenArchive(&sdmcArchive))) {
return(-1);
}
return(0);
}
Result initFS() {
u32 extdata_archive_lowpathdata[3] = { MEDIATYPE_NAND, 0xf000000e, 0 };
extdata_archive = (FS_Archive ) { ARCHIVE_SHARED_EXTDATA,
(FS_Path ) { PATH_BINARY, 0xC,
(u8*) extdata_archive_lowpathdata } };
verListPath = fsMakePath(PATH_ASCII, "/versionList.dat");
return FSUSER_OpenArchive(&extdata_archive);
}
void files_open(FS_ArchiveID archiveId, FS_Path archivePath) {
files_data* data = (files_data*) calloc(1, sizeof(files_data));
if(data == NULL) {
error_display(NULL, NULL, NULL, "Failed to allocate files data.");
return;
}
data->populateData.recursive = false;
data->populateData.includeBase = false;
data->populateData.dirsFirst = true;
data->populateData.filter = files_filter;
data->populateData.filterData = data;
data->populateData.finished = true;
data->populated = false;
data->showDirectories = true;
data->showCias = true;
data->showTickets = true;
data->showMisc = true;
data->archiveId = archiveId;
data->archivePath.type = archivePath.type;
data->archivePath.size = archivePath.size;
if(archivePath.data != NULL) {
data->archivePath.data = calloc(1, data->archivePath.size);
if(data->archivePath.data == NULL) {
error_display(NULL, NULL, NULL, "Failed to allocate files data.");
files_free_data(data);
return;
}
memcpy((void*) data->archivePath.data, archivePath.data, data->archivePath.size);
} else {
data->archivePath.data = NULL;
}
snprintf(data->currDir, FILE_PATH_MAX, "/");
data->dirItem = NULL;
Result res = 0;
if(R_FAILED(res = FSUSER_OpenArchive(&data->archive, archiveId, archivePath))) {
error_display_res(NULL, NULL, NULL, res, "Failed to open file listing archive.");
files_free_data(data);
return;
}
list_display("Files", "A: Select, B: Back, X: Refresh, Y: Dir, Select: Filter", data, files_update, files_draw_top);
}
bool openCartArch(FS_Archive *out)
{
*out = (FS_Archive){ARCHIVE_GAMECARD_SAVEDATA, (FS_Path){PATH_EMPTY, 0, ""}};
Result res = FSUSER_OpenArchive(out);
if(res)
{
return false;
}
return true;
}
Result filesystemInit()
{
Result ret;
ret = _srvGetServiceHandle(&saveGameFsHandle, "fs:USER");
if(ret)return ret;
ret = FSUSER_Initialize(&saveGameFsHandle);
if(ret)return ret;
ret = srvGetServiceHandle(&sdmcFsHandle, "fs:USER");
if(ret)return ret;
saveGameArchive = (FS_archive){0x00000004, (FS_path){PATH_EMPTY, 1, (u8*)""}};
ret = FSUSER_OpenArchive(&saveGameFsHandle, &saveGameArchive);
sdmcArchive = (FS_archive){0x00000009, (FS_path){PATH_EMPTY, 1, (u8*)""}};
ret = FSUSER_OpenArchive(&sdmcFsHandle, &sdmcArchive);
return ret;
}
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;
}
void dumpTicket(void) {
Result res = 0;
Handle nandDir;
u32 entryCount;
FS_dirent dirent;
printf("Opening NAND...\n");
res = FSUSER_OpenArchive(NULL, &nandArchive);
if(res != 0) {
printf("%sError opening NAND!\n%.8lX%s\n", TEXT_RED, res, TEXT_RESET);
return;
}
printf("Opening /...\n");
nandPath.data = (u8 *)nandPathString;
nandPath.size = (wcslen(nandPathString) + 1) * 2;
res = FSUSER_OpenDirectory(NULL, &nandDir, nandArchive, nandPath);
if(res != 0) {
printf("%sError opening /!\n%.8lX%s\n", TEXT_RED, res, TEXT_RESET);
return;
}
printf("Reading...\n");
for(;;) {
res = FSDIR_Read(nandDir, &entryCount, 1, &dirent);
if(res != 0) {
printf("%sError reading dir!\n%.8lX%s\n", TEXT_RED, res, TEXT_RESET);
return;
}
if(entryCount == 0) {
break;
}
utf16_to_utf8(utf8, dirent.name, 0x106);
printf("/%s\n", utf8);
}
printf("Closing /...\n");
res = FSDIR_Close(nandDir);
if(res != 0) {
printf("%sError closing /!\n%.8lX%s\n", TEXT_RED, res, TEXT_RESET);
return;
}
printf("Closing NAND...\n");
res = FSUSER_CloseArchive(NULL, &nandArchive);
if(res != 0) {
printf("%sError closing NAND!\n%.8lX%s\n", TEXT_RED, res, TEXT_RESET);
return;
}
}
u8 internet_access(u8 upDown, int slot, t_stinf *state, u8 *dest, u8 timeout)
{
Result ret;
ret=fsInit();
sdmcArchive=(FS_archive){0x00000009, (FS_path){PATH_EMPTY, 1, (u8*)""}};
FSUSER_OpenArchive(NULL, &sdmcArchive);
ret=SOC_Initialize((u32*)memalign(0x1000, 0x100000), 0x100000);
sprintf(currentPath, "/");
currentIP=(u32)gethostid();
listenfd=-1;
u8 do1(u8 upDown, int slot, t_stinf *state, u8 *dest, u8 timeout);
return do1(upDown, slot, state, dest, timeout);
}
Result clipboard_set_contents(FS_ArchiveID archiveId, FS_Path* archivePath, const char* path, bool contentsOnly) {
clipboard_clear();
clipboard_has = true;
clipboard_contents_only = contentsOnly;
strncpy(clipboard_path, path, FILE_PATH_MAX);
Result res = 0;
if(R_FAILED(res = FSUSER_OpenArchive(&clipboard_archive, archiveId, *archivePath))) {
clipboard_clear();
}
return res;
}
bool openSysSave(FS_Archive *out, const titleData dat)
{
u32 path[2];
path[0] = MEDIATYPE_NAND;
path[1] = (0x00020000 | dat.unique);
*out = (FS_Archive){ARCHIVE_SYSTEM_SAVEDATA, (FS_Path){PATH_BINARY, 8, path}};
Result res = FSUSER_OpenArchive(out);
if(res)
{
showMessage("Error opening system save data! Title may not use it.");
return false;
}
return true;
}
bool openBossExt(FS_Archive *out, const titleData dat)
{
u32 path[3];
path[0] = MEDIATYPE_SD;
path[1] = dat.extdata;
path[2] = 0;
*out = (FS_Archive){ARCHIVE_BOSS_EXTDATA, (FS_Path){PATH_BINARY, 12, path}};
Result res = FSUSER_OpenArchive(out);
if(res)
{
showMessage("Error opening Boss Extdata! Title may not use it.");
return false;
}
return true;
}
bool openSharedExt(FS_Archive *out, u32 id)
{
u32 path[3];
path[0] = MEDIATYPE_NAND;
path[1] = id;
path[2] = 0x00048000;
*out = (FS_Archive){ARCHIVE_SHARED_EXTDATA, (FS_Path){PATH_BINARY, 12, path}};
Result res = FSUSER_OpenArchive(out);
if(res)
{
showMessage("Error opening Shared Extdata!");
logWriteError("Error opening shared", res);
return false;
}
return true;
}
bool openExtdata(FS_Archive *out, const titleData dat, bool showError)
{
u32 path[3];
path[0] = MEDIATYPE_SD;//always sd for extdata
path[1] = dat.extdata;
path[2] = 0;
*out = (FS_Archive){ARCHIVE_EXTDATA, (FS_Path){PATH_BINARY, 12, path}};
Result res = FSUSER_OpenArchive(out);
if(res)
{
if(showError)
showMessage("Error opening ExtData! Title may not use it.");
return false;
}
return true;
}
void dumpArchive(mediatypes_enum mediatype, int i, FS_archiveIds archivetype, char *dirpath, u8 *filebuffer, size_t bufsize) {
u32 extdata_archive_lowpathdata[3] = {mediatype, i, 0};
extdata_archive = (FS_archive){archivetype, (FS_path){PATH_BINARY, 0xC, (u8*)extdata_archive_lowpathdata}};
Result ret = FSUSER_OpenArchive(NULL, &extdata_archive);
if(ret!=0)
{
return;
}
printf("Archive 0x%08x opened.\n", (unsigned int) i);
gfxFlushBuffers();
gfxSwapBuffers();
mkdir(dirpath, 0777);
dumpFolder("/", i, dirpath, filebuffer, bufsize);
FSUSER_CloseArchive(NULL, &extdata_archive);
}
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");
}
void get_config_path()
{
if(strlen(config_base_path) == 0) {
sdmcArchive = (FS_Archive){ARCHIVE_SDMC, (FS_Path){PATH_EMPTY, 1, (u8*)""}};
FSUSER_OpenArchive(&sdmcArchive);
sprintf(config_base_path, "/lynx");
FS_Path dirPath = (FS_Path){PATH_ASCII, strlen(config_base_path)+1, (u8*)config_base_path};
FSUSER_OpenDirectory(&dirHandle, sdmcArchive, dirPath);
if(!dirHandle) sprintf(config_base_path, "/"); //!!
FSDIR_Close(dirHandle);
sprintf(config_roms_path, "%s/%s", config_base_path, "Roms");
sprintf(config_bios_path, "%s/%s", config_base_path, "Bios");
sprintf(config_skin_path, "%s/%s", config_base_path, "Skin");
sprintf(config_save_path, "%s/%s", config_base_path, "Save");
}
}
App appGetCiaInfo(const std::string file, MediaType mediaType) {
if(!serviceRequire("am")) {
return {};
}
FS_archive archive = (FS_archive) {ARCH_SDMC, (FS_path) {PATH_EMPTY, 1, (u8*) ""}};
Result archiveResult = FSUSER_OpenArchive(NULL, &archive);
if(archiveResult != 0) {
platformSetError(serviceParseError((u32) archiveResult));
return {};
}
Handle handle = 0;
Result openResult = FSUSER_OpenFile(NULL, &handle, archive, FS_makePath(PATH_CHAR, file.c_str()), FS_OPEN_READ, FS_ATTRIBUTE_NONE);
if(openResult != 0) {
platformSetError(serviceParseError((u32) openResult));
return {};
}
TitleList titleInfo;
Result infoResult = AM_GetCiaFileInfo(appMediatypeToByte(mediaType), &titleInfo, handle);
if(infoResult != 0) {
platformSetError(serviceParseError((u32) infoResult));
return {};
}
FSFILE_Close(handle);
FSUSER_CloseArchive(NULL, &archive);
App app;
app.titleId = titleInfo.titleID;
app.uniqueId = ((u32*) &titleInfo.titleID)[0];
strcpy(app.productCode, "<N/A>");
app.mediaType = mediaType;
app.platform = appPlatformFromId(((u16*) &titleInfo.titleID)[3]);
app.category = appCategoryFromId(((u16*) &titleInfo.titleID)[2]);
app.version = titleInfo.titleVersion;
app.size = titleInfo.size;
return app;
}
std::vector<std::string> listPayloads() {
std::vector<std::string> files = {};
FS_Archive sdmcArchive;
// Open SD card
if (FSUSER_OpenArchive(&sdmcArchive, ARCHIVE_SDMC, fsMakePath(PATH_EMPTY, NULL)) != 0) {
logPrintf("\nCould not access SD Card (?)\n\n");
return files;
}
// Open source directory
Handle directory = 0;
if (FSUSER_OpenDirectory(&directory, sdmcArchive, fsMakePath(PATH_ASCII, "/luma/payloads")) != 0) {
logPrintf("\nCould not open /luma/payloads\n\n");
FSUSER_CloseArchive(sdmcArchive);
return files;
}
u32 fileRead = 0;
while (true) {
FS_DirectoryEntry entry = {};
FSDIR_Read(directory, &fileRead, 1, &entry);
if (!fileRead) {
break;
}
// Convert name to ASCII (just cut the other bytes) and compare with prefix
char name8[262] = { 0 };
for (size_t i = 0; i < 262; i++) {
name8[i] = entry.name[i] % 0xff;
}
files.push_back(std::string(name8));
}
FSUSER_CloseArchive(sdmcArchive);
return files;
}
int main()
{
// isN3DS = 0;
// aptOpenSession();
// APT_SetAppCpuTimeLimit(NULL, 80); // enables syscore usage
// aptCloseSession();
// APT_CheckNew3DS(NULL, &isN3DS);
sdmcArchive = (FS_archive){ARCH_SDMC, (FS_path){PATH_EMPTY, 1, (u8*)""}};
FSUSER_OpenArchive(NULL, &sdmcArchive);
z26_3ds_Init(); // !!
chdir("sdmc://Atari2600") ;
srand(time(0));
def_LoadDefaults();
LaunchedFromCommandline = 0;
StartInGUI = 1;
GamePaused = 1;
cli_ReadParms("z26.gui");
c_emulator(); /* call emulator */
srv_sound_off();
z26_3ds_quit();!
fflush(parmfp);
fclose(parmfp);
return 0; //MessageCode;
}
void files_open(FS_Archive archive) {
files_data* data = (files_data*) calloc(1, sizeof(files_data));
data->archive = archive;
if(data->archive.lowPath.size > 0) {
data->archivePath = calloc(1, data->archive.lowPath.size);
memcpy(data->archivePath, data->archive.lowPath.data, data->archive.lowPath.size);
data->archive.lowPath.data = data->archivePath;
}
data->archive.handle = 0;
Result res = 0;
if(R_FAILED(res = FSUSER_OpenArchive(&data->archive))) {
error_display_res(NULL, NULL, NULL, res, "Failed to open file listing archive.");
if(data->archivePath != NULL) {
free(data->archivePath);
}
free(data);
return;
}
data->currDir.archive = &data->archive;
snprintf(data->currDir.path, PATH_MAX, "/");
util_get_path_file(data->currDir.name, data->currDir.path, NAME_MAX);
data->currDir.isDirectory = true;
data->currDir.containsCias = false;
data->currDir.size = 0;
data->currDir.isCia = false;
memcpy(&data->parentDir, &data->currDir, sizeof(data->parentDir));
list_display("Files", "A: Select, B: Back, X: Refresh, Y: Directory Action", data, files_update, files_draw_top);
}
void openSDArchive() {
sdmcArchive = (FS_archive) {0x00000009, (FS_path) {PATH_EMPTY, 1, (u8 *) ""}};
FSUSER_OpenArchive(NULL, &sdmcArchive);
}