forked from Mirror/GodMode9
342 lines
10 KiB
C
342 lines
10 KiB
C
#include "draw.h"
|
|
#include "fs.h"
|
|
#include "fatfs/ff.h"
|
|
|
|
// don't use this area for anything else!
|
|
static FATFS* fs = (FATFS*)0x20316000;
|
|
|
|
// reserve one MB for this, just to be safe
|
|
static DirStruct* curdir_contents = (DirStruct*)0x21000000;
|
|
|
|
// this is the main buffer
|
|
static u8* main_buffer = (u8*)0x21100000;
|
|
// this is the main buffer size
|
|
static size_t main_buffer_size = 4 * 1024 * 1024;
|
|
|
|
// number of currently open file systems
|
|
static u32 numfs = 0;
|
|
|
|
bool InitFS()
|
|
{
|
|
#ifndef EXEC_GATEWAY
|
|
// TODO: Magic?
|
|
*(u32*)0x10000020 = 0;
|
|
*(u32*)0x10000020 = 0x340;
|
|
#endif
|
|
for (numfs = 0; numfs < 7; numfs++) {
|
|
char fsname[8];
|
|
snprintf(fsname, 8, "%lu:", numfs);
|
|
int res = f_mount(fs + numfs, fsname, 1);
|
|
if (res != FR_OK) {
|
|
if (numfs >= 4) break;
|
|
ShowPrompt(false, "Initialising failed! (%lu/%s/%i)", numfs, fsname, res);
|
|
DeinitFS();
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void DeinitFS()
|
|
{
|
|
for (u32 i = 0; i < numfs; i++) {
|
|
char fsname[8];
|
|
snprintf(fsname, 7, "%lu:", numfs);
|
|
f_mount(NULL, fsname, 1);
|
|
}
|
|
numfs = 0;
|
|
}
|
|
|
|
bool FileCreate(const char* path, u8* data, u32 size) {
|
|
FIL file;
|
|
UINT bytes_written = 0;
|
|
if (f_open(&file, path, FA_READ | FA_WRITE | FA_CREATE_ALWAYS) != FR_OK)
|
|
return false;
|
|
f_write(&file, data, size, &bytes_written);
|
|
f_close(&file);
|
|
return (bytes_written == size);
|
|
}
|
|
|
|
bool PathCopyWorker(char* dest, char* orig)
|
|
{
|
|
FILINFO fno;
|
|
bool ret = false;
|
|
|
|
if (f_stat(dest, &fno) != FR_OK) return false; // destination directory does not exist
|
|
if (!(fno.fattrib & AM_DIR)) return false; // destination is not a directory (must be at this point)
|
|
if (f_stat(orig, &fno) != FR_OK) return false; // origin does not exist
|
|
|
|
// get filename, build full destination path
|
|
char* oname = strrchr(orig, '/');
|
|
char* dname = dest + strnlen(dest, 256);
|
|
if (oname == NULL) return false; // not a proper origin path
|
|
oname++;
|
|
*(dname++) = '/';
|
|
strncpy(dname, oname, 256 - (dname - dest));
|
|
|
|
// check if destination exists
|
|
if (f_stat(dest, NULL) == FR_OK) {
|
|
char tempstr[40];
|
|
TruncateString(tempstr, dest, 36, 8);
|
|
if (!ShowPrompt(true, "Destination already exists:\n%s\nOverwrite existing file(s)?"))
|
|
return false;
|
|
}
|
|
|
|
// the copy process takes place here
|
|
ShowProgress(0, 0, orig, true);
|
|
if (fno.fattrib & AM_DIR) { // processing folders...
|
|
DIR pdir;
|
|
char* fname = orig + strnlen(orig, 256);
|
|
|
|
*(fname++) = '/';
|
|
fno.lfname = fname;
|
|
fno.lfsize = 256 - (fname - orig);
|
|
|
|
if (f_stat(dest, NULL) != FR_OK)
|
|
f_mkdir(dest);
|
|
if (f_stat(dest, NULL) != FR_OK)
|
|
return false;
|
|
|
|
if (f_opendir(&pdir, orig) != FR_OK)
|
|
return false;
|
|
while (f_readdir(&pdir, &fno) == FR_OK) {
|
|
if ((strncmp(fno.fname, ".", 2) == 0) || (strncmp(fno.fname, "..", 3) == 0))
|
|
continue; // filter out virtual entries
|
|
if (fname[0] == 0)
|
|
strncpy(fname, fno.fname, 256 - (fname - orig));
|
|
if (fno.fname[0] == 0) {
|
|
ret = true;
|
|
break;
|
|
} else if (!PathCopyWorker(dest, orig)) {
|
|
break;
|
|
}
|
|
}
|
|
f_closedir(&pdir);
|
|
} else { // processing files...
|
|
FIL ofile;
|
|
FIL dfile;
|
|
size_t fsize;
|
|
|
|
if (f_open(&ofile, orig, FA_READ | FA_OPEN_EXISTING) != FR_OK)
|
|
return false;
|
|
if (f_open(&dfile, dest, FA_WRITE | FA_CREATE_ALWAYS) != FR_OK) {
|
|
f_close(&ofile);
|
|
return false;
|
|
}
|
|
fsize = f_size(&ofile);
|
|
f_lseek(&dfile, 0);
|
|
f_sync(&dfile);
|
|
f_lseek(&ofile, 0);
|
|
f_sync(&ofile);
|
|
|
|
for (size_t pos = 0; pos < fsize; pos += main_buffer_size) {
|
|
UINT bytes_read = 0;
|
|
UINT bytes_written = 0;
|
|
ShowProgress(pos, fsize, orig, false);
|
|
f_read(&ofile, main_buffer, main_buffer_size, &bytes_read);
|
|
f_write(&dfile, main_buffer, bytes_read, &bytes_written);
|
|
if (bytes_read != bytes_written) {
|
|
ret = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
f_close(&ofile);
|
|
f_close(&dfile);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
bool PathCopy(const char* destdir, const char* orig)
|
|
{
|
|
char fdpath[256]; // 256 is the maximum length of a full path
|
|
char fopath[256];
|
|
strncpy(fdpath, destdir, 256);
|
|
strncpy(fopath, orig, 256);
|
|
return PathCopyWorker(fdpath, fopath);
|
|
}
|
|
|
|
bool PathDeleteWorker(char* fpath)
|
|
{
|
|
FILINFO fno;
|
|
bool ret = true;
|
|
|
|
// the deletion process takes place here
|
|
if (f_stat(fpath, &fno) != FR_OK) return false; // fpath does not exist
|
|
if (fno.fattrib & AM_DIR) { // processing folders...
|
|
DIR pdir;
|
|
char* fname = fpath + strnlen(fpath, 256);
|
|
|
|
*(fname++) = '/';
|
|
fno.lfname = fname;
|
|
fno.lfsize = 256 - (fname - fpath);
|
|
|
|
if (f_opendir(&pdir, fpath) != FR_OK)
|
|
return false;
|
|
while (f_readdir(&pdir, &fno) == FR_OK) {
|
|
if ((strncmp(fno.fname, ".", 2) == 0) || (strncmp(fno.fname, "..", 3) == 0))
|
|
continue; // filter out virtual entries
|
|
if (fname[0] == 0)
|
|
strncpy(fname, fno.fname, 256 - (fname - fpath));
|
|
if (fno.fname[0] == 0) {
|
|
break;
|
|
} else if (!PathDeleteWorker(fpath)) {
|
|
ret = false;
|
|
}
|
|
}
|
|
f_closedir(&pdir);
|
|
} else { // processing files...
|
|
ret = (f_unlink(fpath) == FR_OK);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
bool PathDelete(const char* path)
|
|
{
|
|
char fpath[256]; // 256 is the maximum length of a full path
|
|
strncpy(fpath, path, 256);
|
|
return PathDeleteWorker(fpath);
|
|
}
|
|
|
|
void Screenshot()
|
|
{
|
|
const u8 bmp_header[54] = {
|
|
0x42, 0x4D, 0x36, 0xCA, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x28, 0x00,
|
|
0x00, 0x00, 0x90, 0x01, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x01, 0x00, 0x18, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0xCA, 0x08, 0x00, 0x12, 0x0B, 0x00, 0x00, 0x12, 0x0B, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00
|
|
};
|
|
u8* buffer = main_buffer + 54;
|
|
u8* buffer_t = buffer + (400 * 240 * 3);
|
|
char filename[16];
|
|
static u32 n = 0;
|
|
|
|
for (; n < 1000; n++) {
|
|
snprintf(filename, 16, "0:/snap%03i.bmp", (int) n);
|
|
if (f_stat(filename, NULL) != FR_OK) break;
|
|
}
|
|
if (n >= 1000) return;
|
|
|
|
memcpy(main_buffer, bmp_header, 54);
|
|
memset(buffer, 0x1F, 400 * 240 * 3 * 2);
|
|
for (u32 x = 0; x < 400; x++)
|
|
for (u32 y = 0; y < 240; y++)
|
|
memcpy(buffer_t + (y*400 + x) * 3, TOP_SCREEN0 + (x*240 + y) * 3, 3);
|
|
for (u32 x = 0; x < 320; x++)
|
|
for (u32 y = 0; y < 240; y++)
|
|
memcpy(buffer + (y*400 + x + 40) * 3, BOT_SCREEN0 + (x*240 + y) * 3, 3);
|
|
FileCreate(filename, main_buffer, 54 + (400 * 240 * 3 * 2));
|
|
}
|
|
|
|
bool GetRootDirContentsWorker(DirStruct* contents) {
|
|
static const char* drvname[16] = {
|
|
"SDCARD",
|
|
"SYSNAND CTRNAND", "SYSNAND TWLN", "SYSNAND TWLP",
|
|
"EMUNAND CTRNAND", "EMUNAND TWLN", "EMUNAND TWLP"
|
|
};
|
|
|
|
for (u32 pdrv = 0; (pdrv < numfs) && (pdrv < MAX_ENTRIES); pdrv++) {
|
|
memset(contents->entry[pdrv].path, 0x00, 16);
|
|
snprintf(contents->entry[pdrv].path + 0, 4, "%lu:", pdrv);
|
|
snprintf(contents->entry[pdrv].path + 4, 32, "[%lu:] %s", pdrv, drvname[pdrv]);
|
|
contents->entry[pdrv].name = contents->entry[pdrv].path + 4;
|
|
contents->entry[pdrv].size = GetTotalSpace(contents->entry[pdrv].path);
|
|
contents->entry[pdrv].type = T_FAT_ROOT;
|
|
contents->entry[pdrv].marked = 0;
|
|
}
|
|
contents->n_entries = numfs;
|
|
|
|
return contents->n_entries;
|
|
}
|
|
|
|
bool GetDirContentsWorker(DirStruct* contents, char* fpath, int fsize, bool recursive) {
|
|
DIR pdir;
|
|
FILINFO fno;
|
|
char* fname = fpath + strnlen(fpath, fsize - 1);
|
|
bool ret = false;
|
|
|
|
if (f_opendir(&pdir, fpath) != FR_OK)
|
|
return false;
|
|
(fname++)[0] = '/';
|
|
fno.lfname = fname;
|
|
fno.lfsize = fsize - (fname - fpath);
|
|
|
|
while (f_readdir(&pdir, &fno) == FR_OK) {
|
|
if ((strncmp(fno.fname, ".", 2) == 0) || (strncmp(fno.fname, "..", 3) == 0))
|
|
continue; // filter out virtual entries
|
|
if (fname[0] == 0)
|
|
strncpy(fname, fno.fname, (fsize - 1) - (fname - fpath));
|
|
if (fno.fname[0] == 0) {
|
|
ret = true;
|
|
break;
|
|
} else {
|
|
DirEntry* entry = &(contents->entry[contents->n_entries]);
|
|
strncpy(entry->path, fpath, 256);
|
|
entry->name = entry->path + (fname - fpath);
|
|
if (fno.fattrib & AM_DIR) {
|
|
entry->type = T_FAT_DIR;
|
|
entry->size = 0;
|
|
} else {
|
|
entry->type = T_FAT_FILE;
|
|
entry->size = fno.fsize;
|
|
}
|
|
entry->marked = 0;
|
|
contents->n_entries++;
|
|
if (contents->n_entries >= MAX_ENTRIES)
|
|
break;
|
|
}
|
|
if (recursive && (fno.fattrib & AM_DIR)) {
|
|
if (!GetDirContentsWorker(contents, fpath, fsize, recursive))
|
|
break;
|
|
}
|
|
}
|
|
f_closedir(&pdir);
|
|
|
|
return ret;
|
|
}
|
|
|
|
DirStruct* GetDirContents(const char* path) {
|
|
curdir_contents->n_entries = 0;
|
|
if (strncmp(path, "", 256) == 0) { // root directory
|
|
if (!GetRootDirContentsWorker(curdir_contents))
|
|
curdir_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);
|
|
if (!GetDirContentsWorker(curdir_contents, fpath, 256, false))
|
|
curdir_contents->n_entries = 0;
|
|
}
|
|
|
|
return curdir_contents;
|
|
}
|
|
|
|
uint64_t GetFreeSpace(const char* path)
|
|
{
|
|
DWORD free_clusters;
|
|
FATFS *fs_ptr;
|
|
char fsname[4] = { '\0' };
|
|
int fsnum = -1;
|
|
|
|
strncpy(fsname, path, 2);
|
|
fsnum = *fsname - (int) '0';
|
|
if ((fsnum < 0) || (fsnum >= 7) || (fsname[1] != ':'))
|
|
return -1;
|
|
if (f_getfree(fsname, &free_clusters, &fs_ptr) != FR_OK)
|
|
return -1;
|
|
|
|
return (uint64_t) free_clusters * fs[fsnum].csize * _MAX_SS;
|
|
}
|
|
|
|
uint64_t GetTotalSpace(const char* path)
|
|
{
|
|
int fsnum = -1;
|
|
|
|
fsnum = *path - (int) '0';
|
|
if ((fsnum < 0) || (fsnum >= 7) || (path[1] != ':'))
|
|
return -1;
|
|
|
|
return (uint64_t) (fs[fsnum].n_fatent - 2) * fs[fsnum].csize * _MAX_SS;
|
|
}
|