Mirror/GodMode9
1
0
Fork 1
mirror of https://github.com/d0k3/GodMode9.git synced 2025-06-26 13:42:47 +00:00
Code Issues Packages Projects Releases Wiki Activity

Allow listing virtual files

Browse Source
This commit is contained in:
d0k3 2016-03-21 18:29:55 +01:00
parent ba61f77ee0
commit ad995919cf
3 changed files with 160 additions and 20 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

71
source/fs.c
View File

@ -1,5 +1,6 @@
#include "draw.h"
#include "fs.h"
#include "virtual.h"
#include "fatfs/ff.h"
#define MAX_FS 7
@ -55,7 +56,7 @@ void DeinitFS() {
int PathToNumFS(const char* path) {
int fsnum = *path - (int) '0';
if ((fsnum < 0) || (fsnum >= MAX_FS) || (path[1] != ':')) {
ShowPrompt(false, "Invalid path");
if (!IsVirtualPath(path)) ShowPrompt(false, "Invalid path (%s)", path);
return -1;
}
return fsnum;
@ -63,7 +64,11 @@ int PathToNumFS(const char* path) {
bool CheckWritePermissions(const char* path) {
int pdrv = PathToNumFS(path);
if (pdrv < 0) return false;
if (pdrv < 0) {
if (IsVirtualPath(path)) // this is a hack, but okay for now
pdrv = (*path == 'S') ? 1 : 4;
else return false;
}
if ((pdrv >= 1) && (pdrv <= 3) && (write_permission_level < 3)) {
if (ShowPrompt(true, "Writing to the SysNAND is locked!\nUnlock it now?"))
@ -375,22 +380,30 @@ void SortDirStruct(DirStruct* contents) {
}
bool GetRootDirContentsWorker(DirStruct* contents) {
static const char* drvname[16] = {
static const char* drvname[] = {
"SDCARD",
"SYSNAND CTRNAND", "SYSNAND TWLN", "SYSNAND TWLP",
"EMUNAND CTRNAND", "EMUNAND TWLN", "EMUNAND TWLP"
"EMUNAND CTRNAND", "EMUNAND TWLN", "EMUNAND TWLP",
"SYSNAND VIRTUAL", "EMUNAND VIRTUAL"
};
static const char* drvnum[] = {
"0", "1", "2", "3", "4", "5", "6", "S", "E"
};
u32 n_entries = 0;
for (u32 pdrv = 0; (pdrv < MAX_FS) && (pdrv < MAX_ENTRIES); pdrv++) {
if (!fs_mounted[pdrv]) continue;
memset(contents->entry[n_entries].path, 0x00, 16);
snprintf(contents->entry[n_entries].path + 0, 4, "%lu:", pdrv);
snprintf(contents->entry[n_entries].path + 4, 32, "[%lu:] %s", pdrv, drvname[pdrv]);
contents->entry[n_entries].name = contents->entry[n_entries].path + 4;
contents->entry[n_entries].size = GetTotalSpace(contents->entry[n_entries].path);
contents->entry[n_entries].type = T_ROOT;
contents->entry[n_entries].marked = 0;
// virtual root objects hacked in
for (u32 pdrv = 0; (pdrv < MAX_FS+2) && (n_entries < MAX_ENTRIES); pdrv++) {
DirEntry* entry = &(contents->entry[n_entries]);
if ((pdrv < MAX_FS) && !fs_mounted[pdrv]) continue;
if ((pdrv == MAX_FS+0) && (!fs_mounted[1] || !fs_mounted[2] || !fs_mounted[3])) continue;
if ((pdrv == MAX_FS+1) && (!fs_mounted[4] || !fs_mounted[5] || !fs_mounted[6])) continue;
memset(entry->path, 0x00, 64);
snprintf(entry->path + 0, 4, "%s:", drvnum[pdrv]);
snprintf(entry->path + 4, 32, "[%s:] %s", drvnum[pdrv], drvname[pdrv]);
entry->name = entry->path + 4;
entry->size = GetTotalSpace(entry->path);
entry->type = T_ROOT;
entry->marked = 0;
n_entries++;
}
contents->n_entries = n_entries;
@ -398,6 +411,23 @@ bool GetRootDirContentsWorker(DirStruct* contents) {
return contents->n_entries;
}
bool GetVirtualDirContentsWorker(DirStruct* contents, const char* path) {
if (strchr(path, '/')) return false; // only top level paths
for (u32 n = 0; (n < virtualFileList_size) && (contents->n_entries < MAX_ENTRIES); n++) {
VirtualFile vfile;
DirEntry* entry = &(contents->entry[contents->n_entries]);
snprintf(entry->path, 256, "%s/%s", path, virtualFileList[n]);
if (!FindVirtualFile(&vfile, entry->path)) continue;
entry->name = entry->path + strnlen(path, 256) + 1;
entry->size = vfile.size;
entry->type = T_FILE;
entry->marked = 0;
contents->n_entries++;
}
return true; // not much we can check here
}
bool GetDirContentsWorker(DirStruct* contents, char* fpath, int fsize, bool recursive) {
DIR pdir;
FILINFO fno;
@ -450,8 +480,6 @@ void GetDirContents(DirStruct* contents, const char* path) {
if (!GetRootDirContentsWorker(contents))
contents->n_entries = 0; // not required, but so what?
} else {
char fpath[256]; // 256 is the maximum length of a full path
strncpy(fpath, path, 256);
// create virtual '..' entry
contents->entry->name = contents->entry->path + 8;
strncpy(contents->entry->path, "*?*?*", 8);
@ -459,8 +487,15 @@ void GetDirContents(DirStruct* contents, const char* path) {
contents->entry->type = T_DOTDOT;
contents->entry->size = 0;
contents->n_entries = 1;
if (IsVirtualPath(path)) {
if (!GetVirtualDirContentsWorker(contents, path))
contents->n_entries = 0;
} else {
char fpath[256]; // 256 is the maximum length of a full path
strncpy(fpath, path, 256);
if (!GetDirContentsWorker(contents, fpath, 256, false))
contents->n_entries = 0;
}
SortDirStruct(contents);
}
}
@ -471,11 +506,11 @@ uint64_t GetFreeSpace(const char* path)
FATFS *fs_ptr;
char fsname[4] = { '\0' };
int pdrv = PathToNumFS(path);
if (pdrv < 0) return -1;
if (pdrv < 0) return 0;
snprintf(fsname, 3, "%i:", pdrv);
if (f_getfree(fsname, &free_clusters, &fs_ptr) != FR_OK)
return -1;
return 0;
return (uint64_t) free_clusters * fs[pdrv].csize * _MAX_SS;
}
@ -483,7 +518,7 @@ uint64_t GetFreeSpace(const char* path)
uint64_t GetTotalSpace(const char* path)
{
int pdrv = PathToNumFS(path);
if (pdrv < 0) return -1;
if (pdrv < 0) return 0;
return (uint64_t) (fs[pdrv].n_fatent - 2) * fs[pdrv].csize * _MAX_SS;
}

80
source/nand/virtual.c Normal file
View File

@ -0,0 +1,80 @@
#include "virtual.h"
#include "sdmmc.h"
#define VFLAG_ON_O3DS NAND_TYPE_O3DS
#define VFLAG_ON_N3DS NAND_TYPE_N3DS
#define VFLAG_ON_NO3DS NAND_TYPE_NO3DS
#define VFLAG_ON_ALL (VFLAG_ON_O3DS | VFLAG_ON_N3DS | VFLAG_ON_NO3DS)
#define VFLAG_NAND_SIZE (1<<29)
#define VFLAG_ON_EMUNAND (1<<30)
VirtualFile virtualFileTemplates[] = {
{ "twln.bin" , 0x00012E00, 0x08FB5200, 0x03, VFLAG_ON_ALL | VFLAG_EXT_NAND_REMOUNT },
{ "twlp.bin" , 0x09011A00, 0x020B6600, 0x03, VFLAG_ON_ALL | VFLAG_EXT_NAND_REMOUNT },
{ "agbsave.bin" , 0x0B100000, 0x00030000, 0x07, VFLAG_ON_ALL },
{ "firm0.bin" , 0x0B130000, 0x00400000, 0x06, VFLAG_ON_ALL },
{ "firm1.bin" , 0x0B530000, 0x00400000, 0x06, VFLAG_ON_ALL },
{ "ctrnand_fat.bin" , 0x0B95CA00, 0x2F3E3600, 0x04, VFLAG_ON_O3DS | VFLAG_EXT_NAND_REMOUNT },
{ "ctrnand_fat.bin" , 0x0B95AE00, 0x41D2D200, 0x05, VFLAG_ON_N3DS | VFLAG_EXT_NAND_REMOUNT },
{ "ctrnand_fat.bin" , 0x0B95AE00, 0x41D2D200, 0x04, VFLAG_ON_NO3DS | VFLAG_EXT_NAND_REMOUNT },
{ "ctrnand_full.bin" , 0x0B930000, 0x2F5D0000, 0x04, VFLAG_ON_O3DS | VFLAG_EXT_NAND_REMOUNT },
{ "ctrnand_full.bin" , 0x0B930000, 0x41ED0000, 0x05, VFLAG_ON_N3DS | VFLAG_EXT_NAND_REMOUNT },
{ "ctrnand_full.bin" , 0x0B930000, 0x41ED0000, 0x04, VFLAG_ON_NO3DS | VFLAG_EXT_NAND_REMOUNT },
{ "nand.bin" , 0x00000000, 0x00000000, 0xFF, VFLAG_ON_ALL | VFLAG_NAND_SIZE | VFLAG_EXT_NAND_REMOUNT },
{ "nand_minsize.bin" , 0x00000000, 0x3AF00000, 0xFF, VFLAG_ON_O3DS | VFLAG_EXT_NAND_REMOUNT },
{ "nand_minsize.bin" , 0x00000000, 0x4D800000, 0xFF, VFLAG_ON_N3DS | VFLAG_ON_NO3DS | VFLAG_EXT_NAND_REMOUNT },
{ "nand_hdr.bin" , 0x00000000, 0x00000200, 0xFF, VFLAG_ON_ALL },
{ "sector0x96.bin" , 0x00012C00, 0x00000200, 0xFF, VFLAG_ON_ALL }
};
bool IsVirtualPath(const char* path) {
return (strncmp(path, "S:", 2) == 0) || (strncmp(path, "E:", 2) == 0);
}
bool FindVirtualFile(VirtualFile* vfile, const char* path)
{
char* fname = strchr(path, '/');
bool on_emunand = (*path == 'E');
u8 nand_type = CheckNandType(on_emunand);
// fix the name
if (!fname) return false;
fname++;
// more safety checks
if (!IsVirtualPath(path) || (fname - path != 3))
return false;
// parse the template list, get the correct one
u32 n_templates = sizeof(virtualFileTemplates) / sizeof(VirtualFile);
VirtualFile* curr_template = NULL;
for (u32 i = 0; i < n_templates; i++) {
curr_template = &virtualFileTemplates[i];
if ((curr_template->flags & nand_type) && (strncmp(fname, curr_template->name, 32) == 0))
break;
curr_template = NULL;
}
if (!curr_template) return false;
// copy current template to vfile
memcpy(vfile, curr_template, sizeof(VirtualFile));
// process special flags
if (vfile->flags & VFLAG_NAND_SIZE)
vfile->size = getMMCDevice(0)->total_size * 0x200;
if (on_emunand) vfile->flags |= VFLAG_ON_EMUNAND;
return true;
}
int ReadVirtualFile(const VirtualFile* vfile, u8* buffer, u32 offset, u32 count)
{
// simple wrapper function for ReadNandSectors(u8* buffer, u32 sector, u32 count, u32 keyslot, bool read_emunand)
return ReadNandSectors(buffer, (vfile->offset + offset) / 0x200, (count+0x1FF) / 0x200, vfile->keyslot, vfile->flags & VFLAG_ON_EMUNAND);
}
int WriteVirtualFile(const VirtualFile* vfile, const u8* buffer, u32 offset, u32 count)
{
// simple wrapper function for WriteNandSectors(const u8* buffer, u32 sector, u32 count, u32 keyslot, bool write_emunand)
return WriteNandSectors(buffer, (vfile->offset + offset) / 0x200, (count+0x1FF) / 0x200, vfile->keyslot, vfile->flags & VFLAG_ON_EMUNAND);
}

25
source/nand/virtual.h Normal file
View File

@ -0,0 +1,25 @@
#pragma once
#include "common.h"
#include "nand.h"
#define VFLAG_EXT_NAND_REMOUNT (1<<31)
static const char* virtualFileList[] = { // must have a match in virtualFileTemplates[]
"twln.bin", "twlp.bin", "agbsave.bin", "firm0.bin", "firm1.bin", "ctrnand_fat.bin", "ctrnand_full.bin",
"nand.bin", "nand_minsize.bin", "nand_hdr.bin", "sector0x96.bin"
};
static const u32 virtualFileList_size = sizeof(virtualFileList) / sizeof(char*);
typedef struct {
const char name[32];
u32 offset; // must be a multiple of 0x200
u32 size;
u32 keyslot;
u32 flags;
} __attribute__((packed)) VirtualFile;
bool IsVirtualPath(const char* path);
bool FindVirtualFile(VirtualFile* vfile, const char* path);
int ReadVirtualFile(const VirtualFile* vfile, u8* buffer, u32 offset, u32 count);
int WriteVirtualFile(const VirtualFile* vfile, const u8* buffer, u32 offset, u32 count);