joel16/VitaShell
1
0
Fork 0
mirror of https://github.com/joel16/VitaShell.git synced 2024-11-26 21:30:45 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
a4829945cc
VitaShell/file.c
TheFloW acf8956404 Moved browser related stuff to browser.c
2018-09-13 14:46:10 +02:00

1205 lines
30 KiB
C
Raw Blame History

/*
VitaShell
Copyright (C) 2015-2018, TheFloW
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "main.h"
#include "browser.h"
#include "init.h"
#include "archive.h"
#include "file.h"
#include "utils.h"
#include "sha1.h"
#include "strnatcmp.h"
static char *devices[] = {
"gro0:",
"grw0:",
"imc0:",
"os0:",
"pd0:",
"sa0:",
"sd0:",
"tm0:",
"ud0:",
"uma0:",
"ur0:",
"ux0:",
"vd0:",
"vs0:",
"xmc0:",
"host0:",
};
#define N_DEVICES (sizeof(devices) / sizeof(char **))
const char symlink_header_bytes[SYMLINK_HEADER_SIZE] = {0xF1, 0x1E, 0x00, 0x00};
int allocateReadFile(const char *file, void **buffer) {
SceUID fd = sceIoOpen(file, SCE_O_RDONLY, 0);
if (fd < 0)
return fd;
int size = sceIoLseek32(fd, 0, SCE_SEEK_END);
sceIoLseek32(fd, 0, SCE_SEEK_SET);
*buffer = malloc(size);
if (!*buffer) {
sceIoClose(fd);
return VITASHELL_ERROR_NO_MEMORY;
}
int read = sceIoRead(fd, *buffer, size);
sceIoClose(fd);
return read;
}
int ReadFile(const char *file, void *buf, int size) {
SceUID fd = sceIoOpen(file, SCE_O_RDONLY, 0);
if (fd < 0)
return fd;
int read = sceIoRead(fd, buf, size);
sceIoClose(fd);
return read;
}
int WriteFile(const char *file, const void *buf, int size) {
SceUID fd = sceIoOpen(file, SCE_O_WRONLY | SCE_O_CREAT | SCE_O_TRUNC, 0777);
if (fd < 0)
return fd;
int written = sceIoWrite(fd, buf, size);
sceIoClose(fd);
return written;
}
int getFileSize(const char *file) {
SceUID fd = sceIoOpen(file, SCE_O_RDONLY, 0);
if (fd < 0)
return fd;
int fileSize = sceIoLseek(fd, 0, SCE_SEEK_END);
sceIoClose(fd);
return fileSize;
}
int checkFileExist(const char *file) {
SceUID fd = sceIoOpen(file, SCE_O_RDONLY, 0);
if (fd < 0)
return 0;
sceIoClose(fd);
return 1;
}
int checkFolderExist(const char *folder) {
SceUID dfd = sceIoDopen(folder);
if (dfd < 0)
return 0;
sceIoDclose(dfd);
return 1;
}
int getFileSha1(const char *file, uint8_t *pSha1Out, FileProcessParam *param) {
// Set up SHA1 context
SHA1_CTX ctx;
sha1_init(&ctx);
// Open the file to read, else return the error
SceUID fd = sceIoOpen(file, SCE_O_RDONLY, 0);
if (fd < 0)
return fd;
// Open up the buffer for copying data into
void *buf = memalign(4096, TRANSFER_SIZE);
// Actually take the SHA1 sum
while (1) {
int read = sceIoRead(fd, buf, TRANSFER_SIZE);
if (read < 0) {
free(buf);
sceIoClose(fd);
return read;
}
if (read == 0)
break;
sha1_update(&ctx, buf, read);
if (param) {
// Defined in io_process.c, check to make sure pointer isn't null before incrementing
if (param->value)
(*param->value)++; // Note: Max value is filesize/TRANSFER_SIZE
if (param->SetProgress)
param->SetProgress(param->value ? *param->value : 0, param->max);
// Check to see if param->cancelHandler exists, if so call it and free memory if canceled
if (param->cancelHandler && param->cancelHandler()) {
free(buf);
sceIoClose(fd);
return 0;
}
// This is CPU intensive so the progress bar won't refresh unless we sleep
// DIALOG_WAIT seemed too long for this application
// so I set it to 1/2 of a second every 8192 TRANSFER_SIZE blocks
if ((*param->value) % 8192 == 0)
sceKernelDelayThread(500000);
}
}
// Final iteration of SHA1 sum, dump final value into pSha1Out buffer
sha1_final(&ctx, pSha1Out);
// Free up file buffer
free(buf);
// Close file proper
sceIoClose(fd);
return 1;
}
int getPathInfo(const char *path, uint64_t *size, uint32_t *folders,
uint32_t *files, int (* handler)(const char *path)) {
SceUID dfd = sceIoDopen(path);
if (dfd >= 0) {
int res = 0;
do {
SceIoDirent dir;
memset(&dir, 0, sizeof(SceIoDirent));
res = sceIoDread(dfd, &dir);
if (res > 0) {
char *new_path = malloc(strlen(path) + strlen(dir.d_name) + 2);
snprintf(new_path, MAX_PATH_LENGTH, "%s%s%s", path, hasEndSlash(path) ? "" : "/", dir.d_name);
if (handler && handler(new_path)) {
free(new_path);
continue;
}
if (SCE_S_ISDIR(dir.d_stat.st_mode)) {
int ret = getPathInfo(new_path, size, folders, files, handler);
if (ret <= 0) {
free(new_path);
sceIoDclose(dfd);
return ret;
}
} else {
if (size)
(*size) += dir.d_stat.st_size;
if (files)
(*files)++;
}
free(new_path);
}
} while (res > 0);
sceIoDclose(dfd);
if (folders)
(*folders)++;
} else {
if (handler && handler(path))
return 1;
if (size) {
SceIoStat stat;
memset(&stat, 0, sizeof(SceIoStat));
int res = sceIoGetstat(path, &stat);
if (res < 0)
return res;
(*size) += stat.st_size;
}
if (files)
(*files)++;
}
return 1;
}
int removePath(const char *path, FileProcessParam *param) {
SceUID dfd = sceIoDopen(path);
if (dfd >= 0) {
int res = 0;
do {
SceIoDirent dir;
memset(&dir, 0, sizeof(SceIoDirent));
res = sceIoDread(dfd, &dir);
if (res > 0) {
char *new_path = malloc(strlen(path) + strlen(dir.d_name) + 2);
snprintf(new_path, MAX_PATH_LENGTH, "%s%s%s", path, hasEndSlash(path) ? "" : "/", dir.d_name);
if (SCE_S_ISDIR(dir.d_stat.st_mode)) {
int ret = removePath(new_path, param);
if (ret <= 0) {
free(new_path);
sceIoDclose(dfd);
return ret;
}
} else {
int ret = sceIoRemove(new_path);
if (ret < 0) {
free(new_path);
sceIoDclose(dfd);
return ret;
}
if (param) {
if (param->value)
(*param->value)++;
if (param->SetProgress)
param->SetProgress(param->value ? *param->value : 0, param->max);
if (param->cancelHandler && param->cancelHandler()) {
free(new_path);
sceIoDclose(dfd);
return 0;
}
}
}
free(new_path);
}
} while (res > 0);
sceIoDclose(dfd);
int ret = sceIoRmdir(path);
if (ret < 0)
return ret;
if (param) {
if (param->value)
(*param->value)++;
if (param->SetProgress)
param->SetProgress(param->value ? *param->value : 0, param->max);
if (param->cancelHandler && param->cancelHandler()) {
return 0;
}
}
} else {
int ret = sceIoRemove(path);
if (ret < 0)
return ret;
if (param) {
if (param->value)
(*param->value)++;
if (param->SetProgress)
param->SetProgress(param->value ? *param->value : 0, param->max);
if (param->cancelHandler && param->cancelHandler()) {
return 0;
}
}
}
return 1;
}
int copyFile(const char *src_path, const char *dst_path, FileProcessParam *param) {
// The source and destination paths are identical
if (strcasecmp(src_path, dst_path) == 0) {
return VITASHELL_ERROR_SRC_AND_DST_IDENTICAL;
}
// The destination is a subfolder of the source folder
int len = strlen(src_path);
if (strncasecmp(src_path, dst_path, len) == 0 && (dst_path[len] == '/' || dst_path[len - 1] == '/')) {
return VITASHELL_ERROR_DST_IS_SUBFOLDER_OF_SRC;
}
SceUID fdsrc = sceIoOpen(src_path, SCE_O_RDONLY, 0);
if (fdsrc < 0)
return fdsrc;
SceUID fddst = sceIoOpen(dst_path, SCE_O_WRONLY | SCE_O_CREAT | SCE_O_TRUNC, 0777);
if (fddst < 0) {
sceIoClose(fdsrc);
return fddst;
}
void *buf = memalign(4096, TRANSFER_SIZE);
while (1) {
int read = sceIoRead(fdsrc, buf, TRANSFER_SIZE);
if (read < 0) {
free(buf);
sceIoClose(fddst);
sceIoClose(fdsrc);
sceIoRemove(dst_path);
return read;
}
if (read == 0)
break;
int written = sceIoWrite(fddst, buf, read);
if (written < 0) {
free(buf);
sceIoClose(fddst);
sceIoClose(fdsrc);
sceIoRemove(dst_path);
return written;
}
if (param) {
if (param->value)
(*param->value) += read;
if (param->SetProgress)
param->SetProgress(param->value ? *param->value : 0, param->max);
if (param->cancelHandler && param->cancelHandler()) {
free(buf);
sceIoClose(fddst);
sceIoClose(fdsrc);
sceIoRemove(dst_path);
return 0;
}
}
}
free(buf);
// Inherit file stat
SceIoStat stat;
memset(&stat, 0, sizeof(SceIoStat));
sceIoGetstatByFd(fdsrc, &stat);
sceIoChstatByFd(fddst, &stat, 0x3B);
sceIoClose(fddst);
sceIoClose(fdsrc);
return 1;
}
int copyPath(const char *src_path, const char *dst_path, FileProcessParam *param) {
// The source and destination paths are identical
if (strcasecmp(src_path, dst_path) == 0) {
return VITASHELL_ERROR_SRC_AND_DST_IDENTICAL;
}
// The destination is a subfolder of the source folder
int len = strlen(src_path);
if (strncasecmp(src_path, dst_path, len) == 0 && (dst_path[len] == '/' || dst_path[len - 1] == '/')) {
return VITASHELL_ERROR_DST_IS_SUBFOLDER_OF_SRC;
}
SceUID dfd = sceIoDopen(src_path);
if (dfd >= 0) {
SceIoStat stat;
memset(&stat, 0, sizeof(SceIoStat));
sceIoGetstatByFd(dfd, &stat);
stat.st_mode |= SCE_S_IWUSR;
int ret = sceIoMkdir(dst_path, stat.st_mode & 0xFFF);
if (ret < 0 && ret != SCE_ERROR_ERRNO_EEXIST) {
sceIoDclose(dfd);
return ret;
}
if (ret == SCE_ERROR_ERRNO_EEXIST) {
sceIoChstat(dst_path, &stat, 0x3B);
}
if (param) {
if (param->value)
(*param->value) += DIRECTORY_SIZE;
if (param->SetProgress)
param->SetProgress(param->value ? *param->value : 0, param->max);
if (param->cancelHandler && param->cancelHandler()) {
sceIoDclose(dfd);
return 0;
}
}
int res = 0;
do {
SceIoDirent dir;
memset(&dir, 0, sizeof(SceIoDirent));
res = sceIoDread(dfd, &dir);
if (res > 0) {
char *new_src_path = malloc(strlen(src_path) + strlen(dir.d_name) + 2);
snprintf(new_src_path, MAX_PATH_LENGTH, "%s%s%s", src_path, hasEndSlash(src_path) ? "" : "/", dir.d_name);
char *new_dst_path = malloc(strlen(dst_path) + strlen(dir.d_name) + 2);
snprintf(new_dst_path, MAX_PATH_LENGTH, "%s%s%s", dst_path, hasEndSlash(dst_path) ? "" : "/", dir.d_name);
int ret = 0;
if (SCE_S_ISDIR(dir.d_stat.st_mode)) {
ret = copyPath(new_src_path, new_dst_path, param);
} else {
ret = copyFile(new_src_path, new_dst_path, param);
}
free(new_dst_path);
free(new_src_path);
if (ret <= 0) {
sceIoDclose(dfd);
return ret;
}
}
} while (res > 0);
sceIoDclose(dfd);
} else {
return copyFile(src_path, dst_path, param);
}
return 1;
}
int movePath(const char *src_path, const char *dst_path, int flags, FileProcessParam *param) {
// The source and destination paths are identical
if (strcasecmp(src_path, dst_path) == 0) {
return VITASHELL_ERROR_SRC_AND_DST_IDENTICAL;
}
// The destination is a subfolder of the source folder
int len = strlen(src_path);
if (strncasecmp(src_path, dst_path, len) == 0 && (dst_path[len] == '/' || dst_path[len - 1] == '/')) {
return VITASHELL_ERROR_DST_IS_SUBFOLDER_OF_SRC;
}
int res = sceIoRename(src_path, dst_path);
if (res == SCE_ERROR_ERRNO_EEXIST && flags & (MOVE_INTEGRATE | MOVE_REPLACE)) {
// Src stat
SceIoStat src_stat;
memset(&src_stat, 0, sizeof(SceIoStat));
res = sceIoGetstat(src_path, &src_stat);
if (res < 0)
return res;
// Dst stat
SceIoStat dst_stat;
memset(&dst_stat, 0, sizeof(SceIoStat));
res = sceIoGetstat(dst_path, &dst_stat);
if (res < 0)
return res;
// Is dir
int src_is_dir = SCE_S_ISDIR(src_stat.st_mode);
int dst_is_dir = SCE_S_ISDIR(dst_stat.st_mode);
// One of them is a file and the other a directory, no replacement or integration possible
if (src_is_dir != dst_is_dir)
return VITASHELL_ERROR_INVALID_TYPE;
// Replace file
if (!src_is_dir && !dst_is_dir && flags & MOVE_REPLACE) {
sceIoRemove(dst_path);
res = sceIoRename(src_path, dst_path);
if (res < 0)
return res;
return 1;
}
// Integrate directory
if (src_is_dir && dst_is_dir && flags & MOVE_INTEGRATE) {
SceUID dfd = sceIoDopen(src_path);
if (dfd < 0)
return dfd;
int res = 0;
do {
SceIoDirent dir;
memset(&dir, 0, sizeof(SceIoDirent));
res = sceIoDread(dfd, &dir);
if (res > 0) {
char *new_src_path = malloc(strlen(src_path) + strlen(dir.d_name) + 2);
snprintf(new_src_path, MAX_PATH_LENGTH, "%s%s%s", src_path, hasEndSlash(src_path) ? "" : "/", dir.d_name);
char *new_dst_path = malloc(strlen(dst_path) + strlen(dir.d_name) + 2);
snprintf(new_dst_path, MAX_PATH_LENGTH, "%s%s%s", dst_path, hasEndSlash(dst_path) ? "" : "/", dir.d_name);
// Recursive move
int ret = movePath(new_src_path, new_dst_path, flags, param);
free(new_dst_path);
free(new_src_path);
if (ret <= 0) {
sceIoDclose(dfd);
return ret;
}
}
} while (res > 0);
sceIoDclose(dfd);
// Integrated, now remove this directory
sceIoRmdir(src_path);
}
}
return 1;
}
typedef struct {
char *extension;
int type;
} ExtensionType;
static ExtensionType extension_types[] = {
{ ".7Z", FILE_TYPE_ARCHIVE },
{ ".AR", FILE_TYPE_ARCHIVE },
{ ".BMP", FILE_TYPE_BMP },
{ ".BZ2", FILE_TYPE_ARCHIVE },
{ ".CPIO", FILE_TYPE_ARCHIVE },
{ ".GRZ", FILE_TYPE_ARCHIVE },
{ ".GZ", FILE_TYPE_ARCHIVE },
{ ".INI", FILE_TYPE_INI },
{ ".ISO", FILE_TYPE_ARCHIVE },
{ ".JPEG", FILE_TYPE_JPEG },
{ ".JPG", FILE_TYPE_JPEG },
{ ".LRZ", FILE_TYPE_ARCHIVE },
{ ".LZ", FILE_TYPE_ARCHIVE },
{ ".LZ4", FILE_TYPE_ARCHIVE },
{ ".LZMA", FILE_TYPE_ARCHIVE },
{ ".LZO", FILE_TYPE_ARCHIVE },
{ ".MP3", FILE_TYPE_MP3 },
{ ".MP4", FILE_TYPE_MP4 },
{ ".MTREE", FILE_TYPE_ARCHIVE },
{ ".OGG", FILE_TYPE_OGG },
{ ".PNG", FILE_TYPE_PNG },
{ ".PSARC", FILE_TYPE_ARCHIVE },
{ ".PSP2ARC", FILE_TYPE_ARCHIVE },
{ ".PSP2DMP", FILE_TYPE_PSP2DMP },
{ ".RAR", FILE_TYPE_ARCHIVE },
{ ".SFO", FILE_TYPE_SFO },
{ ".SHAR", FILE_TYPE_ARCHIVE },
{ ".TAR", FILE_TYPE_ARCHIVE },
{ ".TAZ", FILE_TYPE_ARCHIVE },
{ ".TBZ", FILE_TYPE_ARCHIVE },
{ ".TBZ2", FILE_TYPE_ARCHIVE },
{ ".TGZ", FILE_TYPE_ARCHIVE },
{ ".TLZ", FILE_TYPE_ARCHIVE },
{ ".TMP", FILE_TYPE_PSP2DMP },
{ ".TXT", FILE_TYPE_TXT },
{ ".TXZ", FILE_TYPE_ARCHIVE },
{ ".TZ", FILE_TYPE_ARCHIVE },
{ ".TZ2", FILE_TYPE_ARCHIVE },
{ ".TZMA", FILE_TYPE_ARCHIVE },
{ ".TZO", FILE_TYPE_ARCHIVE },
{ ".TZST", FILE_TYPE_ARCHIVE },
{ ".UU", FILE_TYPE_ARCHIVE },
{ ".VPK", FILE_TYPE_VPK },
{ ".WAR", FILE_TYPE_ARCHIVE },
{ ".XAR", FILE_TYPE_ARCHIVE },
{ ".XML", FILE_TYPE_XML },
{ ".XZ", FILE_TYPE_ARCHIVE },
{ ".Z", FILE_TYPE_ARCHIVE },
{ ".ZIP", FILE_TYPE_ARCHIVE },
{ ".ZST", FILE_TYPE_ARCHIVE },
};
int getFileType(const char *file) {
char *p = strrchr(file, '.');
if (p) {
int i;
for (i = 0; i < (sizeof(extension_types) / sizeof(ExtensionType)); i++) {
if (strcasecmp(p, extension_types[i].extension) == 0) {
return extension_types[i].type;
}
}
}
return FILE_TYPE_UNKNOWN;
}
int getNumberOfDevices() {
return N_DEVICES;
}
char **getDevices() {
return devices;
}
FileListEntry *fileListCopyEntry(FileListEntry *src) {
FileListEntry *dst = malloc(sizeof(FileListEntry));
if (!dst)
return NULL;
memcpy(dst, src, sizeof(FileListEntry));
dst->name = malloc(src->name_length + 1);
strcpy(dst->name, src->name);
return dst;
}
FileListEntry *fileListFindEntry(FileList *list, const char *name) {
if (!list)
return NULL;
FileListEntry *entry = list->head;
int name_length = strlen(name);
while (entry) {
if (entry->name_length == name_length && strcasecmp(entry->name, name) == 0)
return entry;
entry = entry->next;
}
return NULL;
}
FileListEntry *fileListGetNthEntry(FileList *list, int n) {
if (!list)
return NULL;
FileListEntry *entry = list->head;
while (n > 0 && entry) {
n--;
entry = entry->next;
}
if (n != 0)
return NULL;
return entry;
}
int fileListGetNumberByName(FileList *list, const char *name) {
if (!list)
return VITASHELL_ERROR_ILLEGAL_ADDR;
FileListEntry *entry = list->head;
int name_length = strlen(name);
int n = 0;
while (entry) {
if (entry->name_length == name_length && strcasecmp(entry->name, name) == 0)
return n;
n++;
entry = entry->next;
}
return VITASHELL_ERROR_NOT_FOUND;
}
void fileListAddEntry(FileList *list, FileListEntry *entry, int sort) {
if (!list || !entry)
return;
entry->next = NULL;
entry->previous = NULL;
if (list->head == NULL) {
list->head = entry;
list->tail = entry;
} else {
if (sort != SORT_NONE) {
FileListEntry *p = list->head;
FileListEntry *previous = NULL;
char entry_name[MAX_NAME_LENGTH];
strcpy(entry_name, entry->name);
removeEndSlash(entry_name);
while (p) {
char p_name[MAX_NAME_LENGTH];
strcpy(p_name, p->name);
removeEndSlash(p_name);
// '..' is always at first
if (strcmp(entry_name, "..") == 0)
break;
if (strcmp(p_name, "..") == 0) {
previous = p;
p = p->next;
continue;
}
// Sort by type
if (sort == SORT_BY_NAME) {
// First folders then files
if (entry->is_folder > p->is_folder)
break;
} else if (sort == SORT_BY_SIZE || sort == SORT_BY_DATE) {
// First files then folders
if (entry->is_folder < p->is_folder)
break;
}
if (sort == SORT_BY_NAME) {
// Sort by name within the same type
if (entry->is_folder == p->is_folder) {
if (strnatcasecmp(entry_name, p_name) < 0) {
break;
}
}
} else if (sort == SORT_BY_SIZE) {
// Sort by name for folders
if (entry->is_folder && p->is_folder) {
if (strnatcasecmp(entry_name, p_name) < 0) {
break;
}
} else if (!entry->is_folder && !p->is_folder) {
// Sort by size for files
if (entry->size > p->size)
break;
// Sort by name for files with the same size
if (entry->size == p->size) {
if (strnatcasecmp(entry_name, p_name) < 0) {
break;
}
}
}
} else if (sort == SORT_BY_DATE) {
if (entry->is_folder == p->is_folder) {
SceRtcTick entry_tick, p_tick;
sceRtcGetTick(&entry->mtime, &entry_tick);
sceRtcGetTick(&p->mtime, &p_tick);
// Sort by date within the same type
if (entry_tick.tick > p_tick.tick)
break;
// Sort by name for files and folders with the same date
if (entry_tick.tick == p_tick.tick) {
if (strnatcasecmp(entry_name, p_name) < 0) {
break;
}
}
}
}
previous = p;
p = p->next;
}
if (previous == NULL) { // Order: entry (new head) -> p (old head)
entry->next = p;
p->previous = entry;
list->head = entry;
} else if (previous->next == NULL) { // Order: p (old tail) -> entry (new tail)
FileListEntry *tail = list->tail;
tail->next = entry;
entry->previous = tail;
list->tail = entry;
} else { // Order: previous -> entry -> p
previous->next = entry;
entry->previous = previous;
entry->next = p;
p->previous = entry;
}
} else {
FileListEntry *tail = list->tail;
tail->next = entry;
entry->previous = tail;
list->tail = entry;
}
}
list->length++;
}
int fileListRemoveEntry(FileList *list, FileListEntry *entry) {
if (!list || !entry)
return 0;
if (entry->previous) {
entry->previous->next = entry->next;
} else {
list->head = entry->next;
}
if (entry->next) {
entry->next->previous = entry->previous;
} else {
list->tail = entry->previous;
}
list->length--;
free(entry->name);
free(entry);
if (list->length == 0) {
list->head = NULL;
list->tail = NULL;
}
return 1;
}
int fileListRemoveEntryByName(FileList *list, const char *name) {
if (!list)
return 0;
FileListEntry *entry = list->head;
FileListEntry *previous = NULL;
int name_length = strlen(name);
while (entry) {
if (entry->name_length == name_length && strcasecmp(entry->name, name) == 0) {
if (previous) {
previous->next = entry->next;
} else {
list->head = entry->next;
}
if (list->tail == entry) {
list->tail = previous;
}
list->length--;
free(entry->name);
free(entry);
if (list->length == 0) {
list->head = NULL;
list->tail = NULL;
}
return 1;
}
previous = entry;
entry = entry->next;
}
return 0;
}
void fileListEmpty(FileList *list) {
if (!list)
return;
FileListEntry *entry = list->head;
while (entry) {
FileListEntry *next = entry->next;
free(entry->name);
free(entry);
entry = next;
}
list->head = NULL;
list->tail = NULL;
list->length = 0;
list->files = 0;
list->folders = 0;
}
int fileListGetDeviceEntries(FileList *list) {
if (!list)
return VITASHELL_ERROR_ILLEGAL_ADDR;
int i;
for (i = 0; i < N_DEVICES; i++) {
if (devices[i]) {
if (is_safe_mode && strcmp(devices[i], "ux0:") != 0)
continue;
SceIoStat stat;
memset(&stat, 0, sizeof(SceIoStat));
if (sceIoGetstat(devices[i], &stat) >= 0) {
FileListEntry *entry = malloc(sizeof(FileListEntry));
if (entry) {
entry->name_length = strlen(devices[i]);
entry->name = malloc(entry->name_length + 1);
strcpy(entry->name, devices[i]);
entry->is_folder = 1;
entry->type = FILE_TYPE_UNKNOWN;
entry->is_symlink = 0;
SceIoDevInfo info;
memset(&info, 0, sizeof(SceIoDevInfo));
int res = sceIoDevctl(entry->name, 0x3001, NULL, 0, &info, sizeof(SceIoDevInfo));
if (res >= 0) {
entry->size = info.free_size;
entry->size2 = info.max_size;
} else {
if (strcmp(devices[i], "ux0:") == 0) {
sceAppMgrGetDevInfo("ux0:", (uint64_t *)&entry->size2, (uint64_t *)&entry->size);
} else {
entry->size = 0;
entry->size2 = 0;
}
}
memcpy(&entry->ctime, (SceDateTime *) &stat.st_ctime, sizeof(SceDateTime));
memcpy(&entry->mtime, (SceDateTime *) &stat.st_mtime, sizeof(SceDateTime));
memcpy(&entry->atime, (SceDateTime *) &stat.st_atime, sizeof(SceDateTime));
fileListAddEntry(list, entry, SORT_BY_NAME);
list->folders++;
}
}
}
}
return 0;
}
int fileListGetDirectoryEntries(FileList *list, const char *path, int sort) {
if (!list)
return VITASHELL_ERROR_ILLEGAL_ADDR;
SceUID dfd = sceIoDopen(path);
if (dfd < 0)
return dfd;
FileListEntry *entry = malloc(sizeof(FileListEntry));
if (entry) {
entry->name_length = strlen(DIR_UP);
entry->name = malloc(entry->name_length + 1);
strcpy(entry->name, DIR_UP);
entry->is_folder = 1;
entry->type = FILE_TYPE_UNKNOWN;
entry->is_symlink = 0;
fileListAddEntry(list, entry, sort);
}
int res = 0;
do {
SceIoDirent dir;
memset(&dir, 0, sizeof(SceIoDirent));
res = sceIoDread(dfd, &dir);
if (res > 0) {
FileListEntry *entry = malloc(sizeof(FileListEntry));
if (entry) {
entry->is_folder = SCE_S_ISDIR(dir.d_stat.st_mode);
entry->is_symlink = 0;
entry->symlink = NULL;
if (entry->is_folder) {
entry->name_length = strlen(dir.d_name) + 1;
entry->name = malloc(entry->name_length + 1);
strcpy(entry->name, dir.d_name);
addEndSlash(entry->name);
entry->type = FILE_TYPE_UNKNOWN;
list->folders++;
} else {
entry->name_length = strlen(dir.d_name);
entry->name = malloc(entry->name_length + 1);
strcpy(entry->name, dir.d_name);
entry->type = getFileType(entry->name);
list->files++;
if (dir.d_stat.st_size <= SYMLINK_MAX_SIZE) {
char *p = malloc(strlen(path) + strlen(dir.d_name) + 2);
if (!p) {
return VITASHELL_ERROR_INTERNAL;
}
snprintf(p, MAX_PATH_LENGTH - 1, "%s%s%s",
path, hasEndSlash(path) ? "" : "/", dir.d_name);
Symlink* symlink = malloc(sizeof(Symlink));
if (!symlink) {
return VITASHELL_ERROR_INTERNAL;
}
int res = resolveSimLink(symlink, p);
if (res < 0) {
if (symlink)
free(symlink);
} else {
entry->is_symlink = 1;
entry->symlink = symlink;
}
free(p);
}
}
entry->size = dir.d_stat.st_size;
memcpy(&entry->ctime, (SceDateTime *) &dir.d_stat.st_ctime, sizeof(SceDateTime));
memcpy(&entry->mtime, (SceDateTime *) &dir.d_stat.st_mtime, sizeof(SceDateTime));
memcpy(&entry->atime, (SceDateTime *) &dir.d_stat.st_atime, sizeof(SceDateTime));
fileListAddEntry(list, entry, sort);
}
}
} while (res > 0);
sceIoDclose(dfd);
return 0;
}
int fileListGetEntries(FileList *list, const char *path, int sort) {
if (!list)
return VITASHELL_ERROR_ILLEGAL_ADDR;
if (isInArchive()) {
return fileListGetArchiveEntries(list, path, sort);
}
if (strcasecmp(path, HOME_PATH) == 0) {
return fileListGetDeviceEntries(list);
}
return fileListGetDirectoryEntries(list, path, sort);
}
// returns < 0 on error
int resolveSimLink(Symlink *symlink, const char *path) {
SceUID fd = sceIoOpen(path, SCE_O_RDONLY, 0);
if (fd < 0)
return VITASHELL_ERROR_SYMLINK_INTERNAL;
char magic[SYMLINK_HEADER_SIZE + 1];
magic[SYMLINK_HEADER_SIZE] = '\0';
if (sceIoRead(fd, &magic, SYMLINK_HEADER_SIZE) < SYMLINK_HEADER_SIZE) {
sceIoClose(fd);
return VITASHELL_ERROR_SYMLINK_INTERNAL;
}
if(memcmp(magic, symlink_header_bytes, SYMLINK_HEADER_SIZE) != 0) {
sceIoClose(fd);
return VITASHELL_ERROR_SYMLINK_INTERNAL;
}
char *resolve = (char *) malloc(MAX_PATH_LENGTH);
if (!resolve) {
sceIoClose(fd);
return VITASHELL_ERROR_INTERNAL;
}
int bytes_read = sceIoRead(fd, resolve, MAX_PATH_LENGTH - 1);
sceIoClose(fd);
if (bytes_read <= 0) {
free(resolve);
return VITASHELL_ERROR_SYMLINK_INTERNAL;
}
resolve[bytes_read] = '\0';
SceIoStat io_stat;
memset(&io_stat, 0, sizeof(SceIoStat));
if (sceIoGetstat(resolve, &io_stat) < 0) {
free(resolve);
return VITASHELL_ERROR_SYMLINK_INTERNAL;
}
symlink->to_file = !SCE_S_ISDIR(io_stat.st_mode);
symlink->target_path = resolve;
symlink->target_path_length = bytes_read + 1;
return 0;
}
// return < 0 on error
int createSymLink(const char *store_location, const char *target) {
SceUID fd = sceIoOpen(store_location, SCE_O_WRONLY | SCE_O_CREAT, 0777);
if (fd < 0) {
return VITASHELL_ERROR_SYMLINK_INTERNAL;
}
sceIoWrite(fd, (void*) &symlink_header_bytes, SYMLINK_HEADER_SIZE);
sceIoWrite(fd, (void*) target, strnlen(target, MAX_PATH_LENGTH));
sceIoClose(fd);
return 0;
}
// get directory path from filename
// result has slash at the end
char * getBaseDirectory(const char * path) {
int i;
int sep_ind = -1;
int len = strlen(path);
if (len > MAX_PATH_LENGTH - 1 || len <= 0) return NULL;
for(i = len - 1; i >=0; i --) {
if (path[i] == '/' || path[i] == ':') {
sep_ind = i;
break;
}
}
if (sep_ind == -1) return NULL;
char * res = (char *) malloc(MAX_PATH_LENGTH);
if (!res) return NULL;
strncpy(res, path, MAX_PATH_LENGTH);
res[sep_ind + 1] = '\0';
return res;
}
// returns NULL when no filename found or error
// result is at most MAX_PATH_LEN
char * getFilename(const char *path) {
int i;
int sep_ind = -1;
int len = strlen(path);
if (len > MAX_PATH_LENGTH || len <= 0) return NULL;
if (path[len - 1] == '/' || path[len - 1] == ':') return NULL; // no file
for(i = len - 1; i >=0; i --) {
if (path[i] == '/' || path[i] == ':') {
sep_ind = i;
break;
}
}
if (sep_ind == -1) return NULL;
char * res = (char *) malloc(MAX_PATH_LENGTH);
if (!res) return NULL;
int new_len = len - (sep_ind + 1);
strncpy(res, path + (sep_ind + 1), new_len); // dont copy separation char
if (new_len + 1 < MAX_PATH_LENGTH)
res[new_len] = '\0';
else
res[MAX_PATH_LENGTH - 1] = '\0';
return res;
}
Reference in New Issue View Git Blame Copy Permalink