diff options
Diffstat (limited to '')
| -rw-r--r-- | src/core/src/file_sys/file_sys.h | 138 | ||||
| -rw-r--r-- | src/core/src/file_sys/file_sys_directory.cpp | 712 | ||||
| -rw-r--r-- | src/core/src/file_sys/file_sys_directory.h | 158 |
3 files changed, 1008 insertions, 0 deletions
diff --git a/src/core/src/file_sys/file_sys.h b/src/core/src/file_sys/file_sys.h new file mode 100644 index 000000000..8611d743f --- /dev/null +++ b/src/core/src/file_sys/file_sys.h @@ -0,0 +1,138 @@ +// Copyright (c) 2012- PPSSPP Project. + +// 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, version 2.0 or later versions. + +// 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 2.0 for more details. + +// A copy of the GPL 2.0 should have been included with the program. +// If not, see http://www.gnu.org/licenses/ + +// Official git repository and contact information can be found at +// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/. + +#pragma once + +#include "common.h" +#include "chunk_file.h" + +enum FileAccess { + FILEACCESS_NONE=0, + FILEACCESS_READ=1, + FILEACCESS_WRITE=2, + FILEACCESS_APPEND=4, + FILEACCESS_CREATE=8 +}; + +enum FileMove { + FILEMOVE_BEGIN=0, + FILEMOVE_CURRENT=1, + FILEMOVE_END=2 +}; + +enum FileType { + FILETYPE_NORMAL=1, + FILETYPE_DIRECTORY=2 +}; + + +class IHandleAllocator { +public: + virtual ~IHandleAllocator() {} + virtual u32 GetNewHandle() = 0; + virtual void FreeHandle(u32 handle) = 0; +}; + +class SequentialHandleAllocator : public IHandleAllocator { +public: + SequentialHandleAllocator() : handle_(1) {} + virtual u32 GetNewHandle() { return handle_++; } + virtual void FreeHandle(u32 handle) {} +private: + int handle_; +}; + +struct PSPFileInfo { + PSPFileInfo() + : size(0), access(0), exists(false), type(FILETYPE_NORMAL), isOnSectorSystem(false), startSector(0), numSectors(0) {} + + void DoState(PointerWrap &p) { + auto s = p.Section("PSPFileInfo", 1); + if (!s) + return; + + p.Do(name); + p.Do(size); + p.Do(access); + p.Do(exists); + p.Do(type); + p.Do(atime); + p.Do(ctime); + p.Do(mtime); + p.Do(isOnSectorSystem); + p.Do(startSector); + p.Do(numSectors); + p.Do(sectorSize); + } + + std::string name; + s64 size; + u32 access; //unix 777 + bool exists; + FileType type; + + tm atime; + tm ctime; + tm mtime; + + bool isOnSectorSystem; + u32 startSector; + u32 numSectors; + u32 sectorSize; +}; + + +class IFileSystem { +public: + virtual ~IFileSystem() {} + + virtual void DoState(PointerWrap &p) = 0; + virtual std::vector<PSPFileInfo> GetDirListing(std::string path) = 0; + virtual u32 OpenFile(std::string filename, FileAccess access, const char *devicename=NULL) = 0; + virtual void CloseFile(u32 handle) = 0; + virtual size_t ReadFile(u32 handle, u8 *pointer, s64 size) = 0; + virtual size_t WriteFile(u32 handle, const u8 *pointer, s64 size) = 0; + virtual size_t SeekFile(u32 handle, s32 position, FileMove type) = 0; + virtual PSPFileInfo GetFileInfo(std::string filename) = 0; + virtual bool OwnsHandle(u32 handle) = 0; + virtual bool MkDir(const std::string &dirname) = 0; + virtual bool RmDir(const std::string &dirname) = 0; + virtual int RenameFile(const std::string &from, const std::string &to) = 0; + virtual bool RemoveFile(const std::string &filename) = 0; + virtual bool GetHostPath(const std::string &inpath, std::string &outpath) = 0; +}; + + +class EmptyFileSystem : public IFileSystem { +public: + virtual void DoState(PointerWrap &p) {} + std::vector<PSPFileInfo> GetDirListing(std::string path) {std::vector<PSPFileInfo> vec; return vec;} + u32 OpenFile(std::string filename, FileAccess access, const char *devicename=NULL) {return 0;} + void CloseFile(u32 handle) {} + size_t ReadFile(u32 handle, u8 *pointer, s64 size) {return 0;} + size_t WriteFile(u32 handle, const u8 *pointer, s64 size) {return 0;} + size_t SeekFile(u32 handle, s32 position, FileMove type) {return 0;} + PSPFileInfo GetFileInfo(std::string filename) {PSPFileInfo f; return f;} + bool OwnsHandle(u32 handle) {return false;} + virtual bool MkDir(const std::string &dirname) {return false;} + virtual bool RmDir(const std::string &dirname) {return false;} + virtual int RenameFile(const std::string &from, const std::string &to) {return -1;} + virtual bool RemoveFile(const std::string &filename) {return false;} + virtual bool GetHostPath(const std::string &inpath, std::string &outpath) {return false;} +}; + + diff --git a/src/core/src/file_sys/file_sys_directory.cpp b/src/core/src/file_sys/file_sys_directory.cpp new file mode 100644 index 000000000..255369cb6 --- /dev/null +++ b/src/core/src/file_sys/file_sys_directory.cpp @@ -0,0 +1,712 @@ +// Copyright (c) 2012- PPSSPP Project. + +// 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, version 2.0 or later versions. + +// 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 2.0 for more details. + +// A copy of the GPL 2.0 should have been included with the program. +// If not, see http://www.gnu.org/licenses/ + +// Official git repository and contact information can be found at +// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/. + +#include "chunk_file.h" +#include "file_util.h" +#include "file_sys_directory.h" +//#include "ISOFileSystem.h" +//#include "Core/HLE/sceKernel.h" +//#include "file/zip_read.h" +//#include "util/text/utf8.h" + +#ifdef _WIN32 +//#include "Common/CommonWindows.h" +#include <sys/stat.h> +#else +#include <dirent.h> +#include <unistd.h> +#include <sys/stat.h> +#include <ctype.h> +#endif + +std::string DirectoryFileHandle::GetLocalPath(std::string& basePath, std::string localpath) +{ + if (localpath.empty()) + return basePath; + + if (localpath[0] == '/') + localpath.erase(0,1); + //Convert slashes +#ifdef _WIN32 + for (size_t i = 0; i < localpath.size(); i++) { + if (localpath[i] == '/') + localpath[i] = '\\'; + } +#endif + return basePath + localpath; +} + +bool DirectoryFileHandle::Open(std::string& basePath, std::string& fileName, FileAccess access) { + std::string fullName = GetLocalPath(basePath,fileName); + INFO_LOG(FILESYS, "Actually opening %s", fullName.c_str()); + + //TODO: tests, should append seek to end of file? seeking in a file opened for append? +#ifdef _WIN32 + // Convert parameters to Windows permissions and access + DWORD desired = 0; + DWORD sharemode = 0; + DWORD openmode = 0; + if (access & FILEACCESS_READ) { + desired |= GENERIC_READ; + sharemode |= FILE_SHARE_READ; + } + if (access & FILEACCESS_WRITE) { + desired |= GENERIC_WRITE; + sharemode |= FILE_SHARE_WRITE; + } + if (access & FILEACCESS_CREATE) { + openmode = OPEN_ALWAYS; + } else { + openmode = OPEN_EXISTING; + } + //Let's do it! + hFile = CreateFile(fullName.c_str(), desired, sharemode, 0, openmode, 0, 0); + bool success = hFile != INVALID_HANDLE_VALUE; +#else + // Convert flags in access parameter to fopen access mode + const char *mode = NULL; + if (access & FILEACCESS_APPEND) { + if (access & FILEACCESS_READ) + mode = "ab+"; // append+read, create if needed + else + mode = "ab"; // append only, create if needed + } else if (access & FILEACCESS_WRITE) { + if (access & FILEACCESS_READ) { + // FILEACCESS_CREATE is ignored for read only, write only, and append + // because C++ standard fopen's nonexistant file creation can only be + // customized for files opened read+write + if (access & FILEACCESS_CREATE) + mode = "wb+"; // read+write, create if needed + else + mode = "rb+"; // read+write, but don't create + } else { + mode = "wb"; // write only, create if needed + } + } else { // neither write nor append, so default to read only + mode = "rb"; // read only, don't create + } + + hFile = fopen(fullName.c_str(), mode); + bool success = hFile != 0; +#endif + +#if HOST_IS_CASE_SENSITIVE + if (!success && + !(access & FILEACCESS_APPEND) && + !(access & FILEACCESS_CREATE) && + !(access & FILEACCESS_WRITE)) + { + if ( ! FixPathCase(basePath,fileName, FPC_PATH_MUST_EXIST) ) + return 0; // or go on and attempt (for a better error code than just 0?) + fullName = GetLocalPath(basePath,fileName); + const char* fullNameC = fullName.c_str(); + + DEBUG_LOG(FILESYS, "Case may have been incorrect, second try opening %s (%s)", fullNameC, fileName.c_str()); + + // And try again with the correct case this time +#ifdef _WIN32 + hFile = CreateFile(fullNameC, desired, sharemode, 0, openmode, 0, 0); + success = hFile != INVALID_HANDLE_VALUE; +#else + hFile = fopen(fullNameC, mode); + success = hFile != 0; +#endif + } +#endif + + return success; +} + +size_t DirectoryFileHandle::Read(u8* pointer, s64 size) +{ + size_t bytesRead = 0; +#ifdef _WIN32 + ::ReadFile(hFile, (LPVOID)pointer, (DWORD)size, (LPDWORD)&bytesRead, 0); +#else + bytesRead = fread(pointer, 1, size, hFile); +#endif + return bytesRead; +} + +size_t DirectoryFileHandle::Write(const u8* pointer, s64 size) +{ + size_t bytesWritten = 0; +#ifdef _WIN32 + ::WriteFile(hFile, (LPVOID)pointer, (DWORD)size, (LPDWORD)&bytesWritten, 0); +#else + bytesWritten = fwrite(pointer, 1, size, hFile); +#endif + return bytesWritten; +} + +size_t DirectoryFileHandle::Seek(s32 position, FileMove type) +{ +#ifdef _WIN32 + DWORD moveMethod = 0; + switch (type) { + case FILEMOVE_BEGIN: moveMethod = FILE_BEGIN; break; + case FILEMOVE_CURRENT: moveMethod = FILE_CURRENT; break; + case FILEMOVE_END: moveMethod = FILE_END; break; + } + DWORD newPos = SetFilePointer(hFile, (LONG)position, 0, moveMethod); + return newPos; +#else + int moveMethod = 0; + switch (type) { + case FILEMOVE_BEGIN: moveMethod = SEEK_SET; break; + case FILEMOVE_CURRENT: moveMethod = SEEK_CUR; break; + case FILEMOVE_END: moveMethod = SEEK_END; break; + } + fseek(hFile, position, moveMethod); + return ftell(hFile); +#endif +} + +void DirectoryFileHandle::Close() +{ +#ifdef _WIN32 + if (hFile != (HANDLE)-1) + CloseHandle(hFile); +#else + if (hFile != 0) + fclose(hFile); +#endif +} + +DirectoryFileSystem::DirectoryFileSystem(IHandleAllocator *_hAlloc, std::string _basePath) : basePath(_basePath) { + File::CreateFullPath(basePath); + hAlloc = _hAlloc; +} + +DirectoryFileSystem::~DirectoryFileSystem() { + for (auto iter = entries.begin(); iter != entries.end(); ++iter) { + iter->second.hFile.Close(); + } +} + +std::string DirectoryFileSystem::GetLocalPath(std::string localpath) { + if (localpath.empty()) + return basePath; + + if (localpath[0] == '/') + localpath.erase(0,1); + //Convert slashes +#ifdef _WIN32 + for (size_t i = 0; i < localpath.size(); i++) { + if (localpath[i] == '/') + localpath[i] = '\\'; + } +#endif + return basePath + localpath; +} + +bool DirectoryFileSystem::MkDir(const std::string &dirname) { +#if HOST_IS_CASE_SENSITIVE + // Must fix case BEFORE attempting, because MkDir would create + // duplicate (different case) directories + + std::string fixedCase = dirname; + if ( ! FixPathCase(basePath,fixedCase, FPC_PARTIAL_ALLOWED) ) + return false; + + return File::CreateFullPath(GetLocalPath(fixedCase)); +#else + return File::CreateFullPath(GetLocalPath(dirname)); +#endif +} + +bool DirectoryFileSystem::RmDir(const std::string &dirname) { + std::string fullName = GetLocalPath(dirname); + +#if HOST_IS_CASE_SENSITIVE + // Maybe we're lucky? + if (File::DeleteDirRecursively(fullName)) + return true; + + // Nope, fix case and try again + fullName = dirname; + if ( ! FixPathCase(basePath,fullName, FPC_FILE_MUST_EXIST) ) + return false; // or go on and attempt (for a better error code than just false?) + + fullName = GetLocalPath(fullName); +#endif + +/*#ifdef _WIN32 + return RemoveDirectory(fullName.c_str()) == TRUE; +#else + return 0 == rmdir(fullName.c_str()); +#endif*/ + return File::DeleteDirRecursively(fullName); +} + +int DirectoryFileSystem::RenameFile(const std::string &from, const std::string &to) { + std::string fullTo = to; + + // Rename ignores the path (even if specified) on to. + size_t chop_at = to.find_last_of('/'); + if (chop_at != to.npos) + fullTo = to.substr(chop_at + 1); + + // Now put it in the same directory as from. + size_t dirname_end = from.find_last_of('/'); + if (dirname_end != from.npos) + fullTo = from.substr(0, dirname_end + 1) + fullTo; + + // At this point, we should check if the paths match and give an already exists error. + if (from == fullTo) + return SCE_KERNEL_ERROR_ERRNO_FILE_ALREADY_EXISTS; + + std::string fullFrom = GetLocalPath(from); + +#if HOST_IS_CASE_SENSITIVE + // In case TO should overwrite a file with different case + if ( ! FixPathCase(basePath,fullTo, FPC_PATH_MUST_EXIST) ) + return -1; // or go on and attempt (for a better error code than just false?) +#endif + + fullTo = GetLocalPath(fullTo); + const char * fullToC = fullTo.c_str(); + +#ifdef _WIN32 + bool retValue = (MoveFile(fullFrom.c_str(), fullToC) == TRUE); +#else + bool retValue = (0 == rename(fullFrom.c_str(), fullToC)); +#endif + +#if HOST_IS_CASE_SENSITIVE + if (! retValue) + { + // May have failed due to case sensitivity on FROM, so try again + fullFrom = from; + if ( ! FixPathCase(basePath,fullFrom, FPC_FILE_MUST_EXIST) ) + return -1; // or go on and attempt (for a better error code than just false?) + fullFrom = GetLocalPath(fullFrom); + +#ifdef _WIN32 + retValue = (MoveFile(fullFrom.c_str(), fullToC) == TRUE); +#else + retValue = (0 == rename(fullFrom.c_str(), fullToC)); +#endif + } +#endif + + // TODO: Better error codes. + return retValue ? 0 : SCE_KERNEL_ERROR_ERRNO_FILE_ALREADY_EXISTS; +} + +bool DirectoryFileSystem::RemoveFile(const std::string &filename) { + std::string fullName = GetLocalPath(filename); +#ifdef _WIN32 + bool retValue = (::DeleteFileA(fullName.c_str()) == TRUE); +#else + bool retValue = (0 == unlink(fullName.c_str())); +#endif + +#if HOST_IS_CASE_SENSITIVE + if (! retValue) + { + // May have failed due to case sensitivity, so try again + fullName = filename; + if ( ! FixPathCase(basePath,fullName, FPC_FILE_MUST_EXIST) ) + return false; // or go on and attempt (for a better error code than just false?) + fullName = GetLocalPath(fullName); + +#ifdef _WIN32 + retValue = (::DeleteFileA(fullName.c_str()) == TRUE); +#else + retValue = (0 == unlink(fullName.c_str())); +#endif + } +#endif + + return retValue; +} + +u32 DirectoryFileSystem::OpenFile(std::string filename, FileAccess access, const char *devicename) { + OpenFileEntry entry; + bool success = entry.hFile.Open(basePath,filename,access); + + if (!success) { +#ifdef _WIN32 + ERROR_LOG(FILESYS, "DirectoryFileSystem::OpenFile: FAILED, %i - access = %i", GetLastError(), (int)access); +#else + ERROR_LOG(FILESYS, "DirectoryFileSystem::OpenFile: FAILED, access = %i", (int)access); +#endif + //wwwwaaaaahh!! + return 0; + } else { +#ifdef _WIN32 + if (access & FILEACCESS_APPEND) + entry.hFile.Seek(0,FILEMOVE_END); +#endif + + u32 newHandle = hAlloc->GetNewHandle(); + entries[newHandle] = entry; + + return newHandle; + } +} + +void DirectoryFileSystem::CloseFile(u32 handle) { + EntryMap::iterator iter = entries.find(handle); + if (iter != entries.end()) { + hAlloc->FreeHandle(handle); + iter->second.hFile.Close(); + entries.erase(iter); + } else { + //This shouldn't happen... + ERROR_LOG(FILESYS,"Cannot close file that hasn't been opened: %08x", handle); + } +} + +bool DirectoryFileSystem::OwnsHandle(u32 handle) { + EntryMap::iterator iter = entries.find(handle); + return (iter != entries.end()); +} + +size_t DirectoryFileSystem::ReadFile(u32 handle, u8 *pointer, s64 size) { + EntryMap::iterator iter = entries.find(handle); + if (iter != entries.end()) + { + size_t bytesRead = iter->second.hFile.Read(pointer,size); + return bytesRead; + } else { + //This shouldn't happen... + ERROR_LOG(FILESYS,"Cannot read file that hasn't been opened: %08x", handle); + return 0; + } +} + +size_t DirectoryFileSystem::WriteFile(u32 handle, const u8 *pointer, s64 size) { + EntryMap::iterator iter = entries.find(handle); + if (iter != entries.end()) + { + size_t bytesWritten = iter->second.hFile.Write(pointer,size); + return bytesWritten; + } else { + //This shouldn't happen... + ERROR_LOG(FILESYS,"Cannot write to file that hasn't been opened: %08x", handle); + return 0; + } +} + +size_t DirectoryFileSystem::SeekFile(u32 handle, s32 position, FileMove type) { + EntryMap::iterator iter = entries.find(handle); + if (iter != entries.end()) { + return iter->second.hFile.Seek(position,type); + } else { + //This shouldn't happen... + ERROR_LOG(FILESYS,"Cannot seek in file that hasn't been opened: %08x", handle); + return 0; + } +} + +PSPFileInfo DirectoryFileSystem::GetFileInfo(std::string filename) { + PSPFileInfo x; + x.name = filename; + + std::string fullName = GetLocalPath(filename); + if (! File::Exists(fullName)) { +#if HOST_IS_CASE_SENSITIVE + if (! FixPathCase(basePath,filename, FPC_FILE_MUST_EXIST)) + return x; + fullName = GetLocalPath(filename); + + if (! File::Exists(fullName)) + return x; +#else + return x; +#endif + } + x.type = File::IsDirectory(fullName) ? FILETYPE_DIRECTORY : FILETYPE_NORMAL; + x.exists = true; + + if (x.type != FILETYPE_DIRECTORY) + { +#ifdef _WIN32 + struct _stat64i32 s; + _wstat64i32(fullName.c_str(), &s); +#else + struct stat s; + stat(fullName.c_str(), &s); +#endif + + x.size = File::GetSize(fullName); + x.access = s.st_mode & 0x1FF; + localtime_r((time_t*)&s.st_atime,&x.atime); + localtime_r((time_t*)&s.st_ctime,&x.ctime); + localtime_r((time_t*)&s.st_mtime,&x.mtime); + } + + return x; +} + +bool DirectoryFileSystem::GetHostPath(const std::string &inpath, std::string &outpath) { + outpath = GetLocalPath(inpath); + return true; +} + +#ifdef _WIN32 +#define FILETIME_FROM_UNIX_EPOCH_US 11644473600000000ULL + +static void tmFromFiletime(tm &dest, FILETIME &src) +{ + u64 from_1601_us = (((u64) src.dwHighDateTime << 32ULL) + (u64) src.dwLowDateTime) / 10ULL; + u64 from_1970_us = from_1601_us - FILETIME_FROM_UNIX_EPOCH_US; + + time_t t = (time_t) (from_1970_us / 1000000UL); + localtime_r(&t, &dest); +} +#endif + +std::vector<PSPFileInfo> DirectoryFileSystem::GetDirListing(std::string path) { + std::vector<PSPFileInfo> myVector; +#ifdef _WIN32 + WIN32_FIND_DATA findData; + HANDLE hFind; + + std::string w32path = GetLocalPath(path) + "\\*.*"; + + hFind = FindFirstFile(ConvertUTF8ToWString(w32path).c_str(), &findData); + + if (hFind == INVALID_HANDLE_VALUE) { + return myVector; //the empty list + } + + while (true) { + PSPFileInfo entry; + if (findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) + entry.type = FILETYPE_DIRECTORY; + else + entry.type = FILETYPE_NORMAL; + + // TODO: Make this more correct? + entry.access = entry.type == FILETYPE_NORMAL ? 0666 : 0777; + // TODO: is this just for .. or all subdirectories? Need to add a directory to the test + // to find out. Also why so different than the old test results? + if (!wcscmp(findData.cFileName, L"..") ) + entry.size = 4096; + else + entry.size = findData.nFileSizeLow | ((u64)findData.nFileSizeHigh<<32); + entry.name = ConvertWStringToUTF8(findData.cFileName); + tmFromFiletime(entry.atime, findData.ftLastAccessTime); + tmFromFiletime(entry.ctime, findData.ftCreationTime); + tmFromFiletime(entry.mtime, findData.ftLastWriteTime); + myVector.push_back(entry); + + int retval = FindNextFile(hFind, &findData); + if (!retval) + break; + } +#else + dirent *dirp; + std::string localPath = GetLocalPath(path); + DIR *dp = opendir(localPath.c_str()); + +#if HOST_IS_CASE_SENSITIVE + if(dp == NULL && FixPathCase(basePath,path, FPC_FILE_MUST_EXIST)) { + // May have failed due to case sensitivity, try again + localPath = GetLocalPath(path); + dp = opendir(localPath.c_str()); + } +#endif + + if (dp == NULL) { + ERROR_LOG(FILESYS,"Error opening directory %s\n",path.c_str()); + return myVector; + } + + while ((dirp = readdir(dp)) != NULL) { + PSPFileInfo entry; + struct stat s; + std::string fullName = GetLocalPath(path) + "/"+dirp->d_name; + stat(fullName.c_str(), &s); + if (S_ISDIR(s.st_mode)) + entry.type = FILETYPE_DIRECTORY; + else + entry.type = FILETYPE_NORMAL; + entry.access = s.st_mode & 0x1FF; + entry.name = dirp->d_name; + entry.size = s.st_size; + localtime_r((time_t*)&s.st_atime,&entry.atime); + localtime_r((time_t*)&s.st_ctime,&entry.ctime); + localtime_r((time_t*)&s.st_mtime,&entry.mtime); + myVector.push_back(entry); + } + closedir(dp); +#endif + return myVector; +} + +void DirectoryFileSystem::DoState(PointerWrap &p) { + if (!entries.empty()) { + p.SetError(p.ERROR_WARNING); + ERROR_LOG(FILESYS, "FIXME: Open files during savestate, could go badly."); + } +} + + + +VFSFileSystem::VFSFileSystem(IHandleAllocator *_hAlloc, std::string _basePath) : basePath(_basePath) { + INFO_LOG(FILESYS, "Creating VFS file system"); + hAlloc = _hAlloc; +} + +VFSFileSystem::~VFSFileSystem() { + for (auto iter = entries.begin(); iter != entries.end(); ++iter) { + delete [] iter->second.fileData; + } + entries.clear(); +} + +std::string VFSFileSystem::GetLocalPath(std::string localPath) { + return basePath + localPath; +} + +bool VFSFileSystem::MkDir(const std::string &dirname) { + // NOT SUPPORTED - READ ONLY + return false; +} + +bool VFSFileSystem::RmDir(const std::string &dirname) { + // NOT SUPPORTED - READ ONLY + return false; +} + +int VFSFileSystem::RenameFile(const std::string &from, const std::string &to) { + // NOT SUPPORTED - READ ONLY + return -1; +} + +bool VFSFileSystem::RemoveFile(const std::string &filename) { + // NOT SUPPORTED - READ ONLY + return false; +} + +u32 VFSFileSystem::OpenFile(std::string filename, FileAccess access, const char *devicename) { + if (access != FILEACCESS_READ) { + ERROR_LOG(FILESYS, "VFSFileSystem only supports plain reading"); + return 0; + } + + std::string fullName = GetLocalPath(filename); + const char *fullNameC = fullName.c_str(); + INFO_LOG(FILESYS,"VFSFileSystem actually opening %s (%s)", fullNameC, filename.c_str()); + + size_t size; + u8 *data = VFSReadFile(fullNameC, &size); + if (!data) { + ERROR_LOG(FILESYS, "VFSFileSystem failed to open %s", filename.c_str()); + return 0; + } + + OpenFileEntry entry; + entry.fileData = data; + entry.size = size; + entry.seekPos = 0; + u32 newHandle = hAlloc->GetNewHandle(); + entries[newHandle] = entry; + return newHandle; +} + +PSPFileInfo VFSFileSystem::GetFileInfo(std::string filename) { + PSPFileInfo x; + x.name = filename; + + std::string fullName = GetLocalPath(filename); + INFO_LOG(FILESYS,"Getting VFS file info %s (%s)", fullName.c_str(), filename.c_str()); + FileInfo fo; + VFSGetFileInfo(fullName.c_str(), &fo); + x.exists = fo.exists; + if (x.exists) { + x.size = fo.size; + x.type = fo.isDirectory ? FILETYPE_DIRECTORY : FILETYPE_NORMAL; + } + INFO_LOG(FILESYS,"Got VFS file info: size = %i", (int)x.size); + return x; +} + +void VFSFileSystem::CloseFile(u32 handle) { + EntryMap::iterator iter = entries.find(handle); + if (iter != entries.end()) { + delete [] iter->second.fileData; + entries.erase(iter); + } else { + //This shouldn't happen... + ERROR_LOG(FILESYS,"Cannot close file that hasn't been opened: %08x", handle); + } +} + +bool VFSFileSystem::OwnsHandle(u32 handle) { + EntryMap::iterator iter = entries.find(handle); + return (iter != entries.end()); +} + +size_t VFSFileSystem::ReadFile(u32 handle, u8 *pointer, s64 size) { + INFO_LOG(FILESYS,"VFSFileSystem::ReadFile %08x %p %i", handle, pointer, (u32)size); + EntryMap::iterator iter = entries.find(handle); + if (iter != entries.end()) + { + size_t bytesRead = size; + memcpy(pointer, iter->second.fileData + iter->second.seekPos, size); + iter->second.seekPos += size; + return bytesRead; + } else { + ERROR_LOG(FILESYS,"Cannot read file that hasn't been opened: %08x", handle); + return 0; + } +} + +size_t VFSFileSystem::WriteFile(u32 handle, const u8 *pointer, s64 size) { + // NOT SUPPORTED - READ ONLY + return 0; +} + +size_t VFSFileSystem::SeekFile(u32 handle, s32 position, FileMove type) { + EntryMap::iterator iter = entries.find(handle); + if (iter != entries.end()) { + switch (type) { + case FILEMOVE_BEGIN: iter->second.seekPos = position; break; + case FILEMOVE_CURRENT: iter->second.seekPos += position; break; + case FILEMOVE_END: iter->second.seekPos = iter->second.size + position; break; + } + return iter->second.seekPos; + } else { + //This shouldn't happen... + ERROR_LOG(FILESYS,"Cannot seek in file that hasn't been opened: %08x", handle); + return 0; + } +} + + +bool VFSFileSystem::GetHostPath(const std::string &inpath, std::string &outpath) { + // NOT SUPPORTED + return false; +} + +std::vector<PSPFileInfo> VFSFileSystem::GetDirListing(std::string path) { + std::vector<PSPFileInfo> myVector; + // TODO + return myVector; +} + +void VFSFileSystem::DoState(PointerWrap &p) { + if (!entries.empty()) { + p.SetError(p.ERROR_WARNING); + ERROR_LOG(FILESYS, "FIXME: Open files during savestate, could go badly."); + } +} diff --git a/src/core/src/file_sys/file_sys_directory.h b/src/core/src/file_sys/file_sys_directory.h new file mode 100644 index 000000000..5591cd7d9 --- /dev/null +++ b/src/core/src/file_sys/file_sys_directory.h @@ -0,0 +1,158 @@ +// Copyright (c) 2012- PPSSPP Project. + +// 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, version 2.0 or later versions. + +// 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 2.0 for more details. + +// A copy of the GPL 2.0 should have been included with the program. +// If not, see http://www.gnu.org/licenses/ + +// Official git repository and contact information can be found at +// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/. + +#ifndef CORE_FILE_SYS_DIRECTORY_H_ +#define CORE_FILE_SYS_DIRECTORY_H_ + +// TODO: Remove the Windows-specific code, FILE is fine there too. + +#include <map> + +#include "file_sys.h" + +#ifdef _WIN32 +typedef void * HANDLE; +#endif + +#if defined(__APPLE__) + +#if TARGET_OS_IPHONE +#define HOST_IS_CASE_SENSITIVE 1 +#elif TARGET_IPHONE_SIMULATOR +#define HOST_IS_CASE_SENSITIVE 0 +#else +// Mac OSX case sensitivity defaults off, but is user configurable (when +// creating a filesytem), so assume the worst: +#define HOST_IS_CASE_SENSITIVE 1 +#endif + +#elif defined(_WIN32) || defined(__SYMBIAN32__) +#define HOST_IS_CASE_SENSITIVE 0 + +#else // Android, Linux, BSD (and the rest?) +#define HOST_IS_CASE_SENSITIVE 1 + +#endif + +#if HOST_IS_CASE_SENSITIVE +enum FixPathCaseBehavior { + FPC_FILE_MUST_EXIST, // all path components must exist (rmdir, move from) + FPC_PATH_MUST_EXIST, // all except the last one must exist - still tries to fix last one (fopen, move to) + FPC_PARTIAL_ALLOWED, // don't care how many exist (mkdir recursive) +}; + +bool FixPathCase(std::string& basePath, std::string &path, FixPathCaseBehavior behavior); +#endif + +struct DirectoryFileHandle +{ +#ifdef _WIN32 + HANDLE hFile; +#else + FILE* hFile; +#endif + DirectoryFileHandle() + { +#ifdef _WIN32 + hFile = (HANDLE)-1; +#else + hFile = 0; +#endif + } + + std::string GetLocalPath(std::string& basePath, std::string localpath); + bool Open(std::string& basePath, std::string& fileName, FileAccess access); + size_t Read(u8* pointer, s64 size); + size_t Write(const u8* pointer, s64 size); + size_t Seek(s32 position, FileMove type); + void Close(); +}; + +class DirectoryFileSystem : public IFileSystem { +public: + DirectoryFileSystem(IHandleAllocator *_hAlloc, std::string _basePath); + ~DirectoryFileSystem(); + + void DoState(PointerWrap &p); + std::vector<PSPFileInfo> GetDirListing(std::string path); + u32 OpenFile(std::string filename, FileAccess access, const char *devicename=NULL); + void CloseFile(u32 handle); + size_t ReadFile(u32 handle, u8 *pointer, s64 size); + size_t WriteFile(u32 handle, const u8 *pointer, s64 size); + size_t SeekFile(u32 handle, s32 position, FileMove type); + PSPFileInfo GetFileInfo(std::string filename); + bool OwnsHandle(u32 handle); + + bool MkDir(const std::string &dirname); + bool RmDir(const std::string &dirname); + int RenameFile(const std::string &from, const std::string &to); + bool RemoveFile(const std::string &filename); + bool GetHostPath(const std::string &inpath, std::string &outpath); + +private: + struct OpenFileEntry { + DirectoryFileHandle hFile; + }; + + typedef std::map<u32, OpenFileEntry> EntryMap; + EntryMap entries; + std::string basePath; + IHandleAllocator *hAlloc; + + // In case of Windows: Translate slashes, etc. + std::string GetLocalPath(std::string localpath); +}; + +// VFSFileSystem: Ability to map in Android APK paths as well! Does not support all features, only meant for fonts. +// Very inefficient - always load the whole file on open. +class VFSFileSystem : public IFileSystem { +public: + VFSFileSystem(IHandleAllocator *_hAlloc, std::string _basePath); + ~VFSFileSystem(); + + void DoState(PointerWrap &p); + std::vector<PSPFileInfo> GetDirListing(std::string path); + u32 OpenFile(std::string filename, FileAccess access, const char *devicename=NULL); + void CloseFile(u32 handle); + size_t ReadFile(u32 handle, u8 *pointer, s64 size); + size_t WriteFile(u32 handle, const u8 *pointer, s64 size); + size_t SeekFile(u32 handle, s32 position, FileMove type); + PSPFileInfo GetFileInfo(std::string filename); + bool OwnsHandle(u32 handle); + + bool MkDir(const std::string &dirname); + bool RmDir(const std::string &dirname); + int RenameFile(const std::string &from, const std::string &to); + bool RemoveFile(const std::string &filename); + bool GetHostPath(const std::string &inpath, std::string &outpath); + +private: + struct OpenFileEntry { + u8 *fileData; + size_t size; + size_t seekPos; + }; + + typedef std::map<u32, OpenFileEntry> EntryMap; + EntryMap entries; + std::string basePath; + IHandleAllocator *hAlloc; + + std::string GetLocalPath(std::string localpath); +}; + +#endif // CORE_FILE_SYS_DIRECTORY_H_ |