/* PS Vita override for R/W SQLite functionality Copyright (C) 2017 VitaSmith Based on original work (C) 2015 xyzz 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 . */ /* Note: We must override part of the default SQlite VFS for full SQLite DB access because the native Vita one, called "psp2", only allows read operations (which Sony probably did to avoid exploit propagation from potential SQLite vulnerabilities). Short of using the VFS overrides below, any attempt to create a new DB or write to an existing one will result in SQLITE_CANTOPEN... */ #include #include #include #include #include "sqlite3.h" //#define VERBOSE 1 #if VERBOSE extern int psvDebugScreenPrintf(const char *format, ...); #define LOG psvDebugScreenPrintf #else #define LOG(...) #endif #define IS_ERROR(x) ((unsigned)x & 0x80000000) static sqlite3_io_methods* rw_methods = NULL; static sqlite3_vfs *rw_vfs = NULL; // The file structure used by Sony typedef struct { sqlite3_file file; int* fd; } vfs_file; static int vita_xWrite(sqlite3_file *file, const void *buf, int count, sqlite_int64 offset) { vfs_file *p = (vfs_file*)file; int seek = sceIoLseek(*p->fd, offset, SCE_SEEK_SET); LOG("seek %08x %x => %x\n", *p->fd, offset, seek); if (seek != offset) return SQLITE_IOERR_WRITE; int write = sceIoWrite(*p->fd, buf, count); LOG("write %08x %08x %x => %x\n", *p->fd, buf, count, write); if (write != count) { LOG("write error %08x\n", write); return SQLITE_IOERR_WRITE; } return SQLITE_OK; } static int vita_xSync(sqlite3_file *file, int flags) { vfs_file *p = (vfs_file*)file; int r = sceIoSyncByFd(*p->fd, 0); LOG("xSync %x, %x => %x\n", *p->fd, flags, r); if (IS_ERROR(r)) return SQLITE_IOERR_FSYNC; return SQLITE_OK; } static int vita_xOpen(sqlite3_vfs *vfs, const char *name, sqlite3_file *file, int flags, int *out_flags) { sqlite3_vfs* org_vfs = (sqlite3_vfs*)vfs->pAppData; LOG("open %s: flags = %08x, ", name, flags); // Default xOpen() does not create files => do that ourselves // TODO: handle SQLITE_OPEN_EXCLUSIVE if (flags & SQLITE_OPEN_CREATE) { SceUID fd = sceIoOpen(name, SCE_O_RDONLY, 0777); if (IS_ERROR(fd)) fd = sceIoOpen(name, SCE_O_WRONLY | SCE_O_CREAT, 0777); if (!IS_ERROR(fd)) sceIoClose(fd); else LOG("create error: %08x\n", fd); } // Call the original xOpen() int r = org_vfs->xOpen(org_vfs, name, file, flags, out_flags); vfs_file *p = (vfs_file*)file; LOG("fd = %08x, r = %d\n", (p == NULL) ? 0 : *p->fd, r); // Default xOpen() also forces read-only on SQLITE_OPEN_READWRITE files if ((file->pMethods != NULL) && (flags & SQLITE_OPEN_READWRITE)) { if (!IS_ERROR(*p->fd)) { // Reopen the file with write access sceIoClose(*p->fd); *p->fd = sceIoOpen(name, SCE_O_RDWR, 0777); LOG("override fd = %08x\n", *p->fd); if (IS_ERROR(*p->fd)) return SQLITE_IOERR_WRITE; } // Need to override xWrite() and xSync() as well if (rw_methods == NULL) { rw_methods = malloc(sizeof(sqlite3_io_methods)); if (rw_methods != NULL) { memcpy(rw_methods, file->pMethods, sizeof(sqlite3_io_methods)); rw_methods->xWrite = vita_xWrite; rw_methods->xSync = vita_xSync; } } if (rw_methods != NULL) file->pMethods = rw_methods; } return r; } static int vita_xDelete(sqlite3_vfs *vfs, const char *name, int syncDir) { int ret = sceIoRemove(name); LOG("delete %s: 0x%08x\n", name, ret); if (IS_ERROR(ret)) return SQLITE_IOERR_DELETE; return SQLITE_OK; } int sqlite_init() { int rc; if (rw_vfs != NULL) return SQLITE_OK; SceSqliteMallocMethods mf = { (void* (*) (int)) malloc, (void* (*) (void*, int)) realloc, free }; sceSqliteConfigMallocMethods(&mf); rw_vfs = malloc(sizeof(sqlite3_vfs)); sqlite3_vfs *vfs = sqlite3_vfs_find(NULL); if ((vfs != NULL) && (rw_vfs != NULL)) { // Override xOpen() and xDelete() memcpy(rw_vfs, vfs, sizeof(sqlite3_vfs)); rw_vfs->zName = "psp2_rw"; rw_vfs->xOpen = vita_xOpen; rw_vfs->xDelete = vita_xDelete; // Keep a copy of the original vfs pointer rw_vfs->pAppData = vfs; rc = sqlite3_vfs_register(rw_vfs, 1); if (rc != SQLITE_OK) { LOG("sqlite_init: could not register vfs: %d\n", rc); return rc; } } return SQLITE_OK; } int sqlite_exit() { int rc = SQLITE_OK; free(rw_methods); rw_methods = NULL; if (rw_vfs != NULL) { rc = sqlite3_vfs_unregister(rw_vfs); if (rc != SQLITE_OK) LOG("sqlite_exit: error unregistering vfs: %d\n", rc); free(rw_vfs); rw_vfs = NULL; } return rc; }