From 63e46abdb8764bc97e91bae862c8d461e61b1965 Mon Sep 17 00:00:00 2001 From: bunnei Date: Tue, 8 Apr 2014 19:25:03 -0400 Subject: got rid of 'src' folders in each sub-project --- src/core/file_sys/directory_file_system.cpp | 671 ++++++++++++++++++++++++++++ src/core/file_sys/directory_file_system.h | 158 +++++++ src/core/file_sys/file_sys.h | 138 ++++++ src/core/file_sys/meta_file_system.cpp | 520 +++++++++++++++++++++ src/core/file_sys/meta_file_system.h | 109 +++++ 5 files changed, 1596 insertions(+) create mode 100644 src/core/file_sys/directory_file_system.cpp create mode 100644 src/core/file_sys/directory_file_system.h create mode 100644 src/core/file_sys/file_sys.h create mode 100644 src/core/file_sys/meta_file_system.cpp create mode 100644 src/core/file_sys/meta_file_system.h (limited to 'src/core/file_sys') diff --git a/src/core/file_sys/directory_file_system.cpp b/src/core/file_sys/directory_file_system.cpp new file mode 100644 index 00000000..29369eec --- /dev/null +++ b/src/core/file_sys/directory_file_system.cpp @@ -0,0 +1,671 @@ +// 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 "directory_file_system.h" +//#include "ISOFileSystem.h" +//#include "Core/HLE/sceKernel.h" +//#include "file/zip_read.h" +#include "utf8.h" + +#if EMU_PLATFORM == PLATFORM_WINDOWS +#include +#include +#else +#include +#include +#include +#include +#endif + +#if HOST_IS_CASE_SENSITIVE +static bool FixFilenameCase(const std::string &path, std::string &filename) +{ + // Are we lucky? + if (File::Exists(path + filename)) + return true; + + size_t filenameSize = filename.size(); // size in bytes, not characters + for (size_t i = 0; i < filenameSize; i++) + { + filename[i] = tolower(filename[i]); + } + + //TODO: lookup filename in cache for "path" + + struct dirent_large { struct dirent entry; char padding[FILENAME_MAX+1]; } diren; + struct dirent_large; + struct dirent *result = NULL; + + DIR *dirp = opendir(path.c_str()); + if (!dirp) + return false; + + bool retValue = false; + + while (!readdir_r(dirp, (dirent*) &diren, &result) && result) + { + if (strlen(result->d_name) != filenameSize) + continue; + + size_t i; + for (i = 0; i < filenameSize; i++) + { + if (filename[i] != tolower(result->d_name[i])) + break; + } + + if (i < filenameSize) + continue; + + filename = result->d_name; + retValue = true; + } + + closedir(dirp); + + return retValue; +} + +bool FixPathCase(std::string& basePath, std::string &path, FixPathCaseBehavior behavior) +{ + size_t len = path.size(); + + if (len == 0) + return true; + + if (path[len - 1] == '/') + { + len--; + + if (len == 0) + return true; + } + + std::string fullPath; + fullPath.reserve(basePath.size() + len + 1); + fullPath.append(basePath); + + size_t start = 0; + while (start < len) + { + size_t i = path.find('/', start); + if (i == std::string::npos) + i = len; + + if (i > start) + { + std::string component = path.substr(start, i - start); + + // Fix case and stop on nonexistant path component + if (FixFilenameCase(fullPath, component) == false) { + // Still counts as success if partial matches allowed or if this + // is the last component and only the ones before it are required + return (behavior == FPC_PARTIAL_ALLOWED || (behavior == FPC_PATH_MUST_EXIST && i >= len)); + } + + path.replace(start, i - start, component); + + fullPath.append(component); + fullPath.append(1, '/'); + } + + start = i + 1; + } + + return true; +} + +#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) +{ +#if HOST_IS_CASE_SENSITIVE + if (access & (FILEACCESS_APPEND|FILEACCESS_CREATE|FILEACCESS_WRITE)) + { + DEBUG_LOG(FILESYS, "Checking case for path %s", fileName.c_str()); + if ( ! FixPathCase(basePath, fileName, FPC_PATH_MUST_EXIST) ) + return false; // or go on and attempt (for a better error code than just 0?) + } + // else we try fopen first (in case we're lucky) before simulating case insensitivity +#endif + + 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(ConvertUTF8ToWString(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 -1;//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(ConvertUTF8ToWString(fullFrom).c_str(), ConvertUTF8ToWString(fullToC).c_str()) == 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 : -1;//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; + } +} + +FileInfo DirectoryFileSystem::GetFileInfo(std::string filename) { + FileInfo 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(ConvertUTF8ToWString(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 DirectoryFileSystem::GetDirListing(std::string path) { + std::vector 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) { + FileInfo 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) { + FileInfo 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."); + } +} diff --git a/src/core/file_sys/directory_file_system.h b/src/core/file_sys/directory_file_system.h new file mode 100644 index 00000000..a11331a2 --- /dev/null +++ b/src/core/file_sys/directory_file_system.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 + +#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 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); + FileInfo 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 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 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); + FileInfo 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 EntryMap; + EntryMap entries; + std::string basePath; + IHandleAllocator *hAlloc; + + std::string GetLocalPath(std::string localpath); +}; + +#endif // CORE_FILE_SYS_DIRECTORY_H_ diff --git a/src/core/file_sys/file_sys.h b/src/core/file_sys/file_sys.h new file mode 100644 index 00000000..b27e36c8 --- /dev/null +++ b/src/core/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 FileInfo { + FileInfo() + : size(0), access(0), exists(false), type(FILETYPE_NORMAL), isOnSectorSystem(false), startSector(0), numSectors(0) {} + + void DoState(PointerWrap &p) { + auto s = p.Section("FileInfo", 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 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 FileInfo 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 GetDirListing(std::string path) {std::vector 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;} + FileInfo GetFileInfo(std::string filename) {FileInfo 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/file_sys/meta_file_system.cpp b/src/core/file_sys/meta_file_system.cpp new file mode 100644 index 00000000..f86c3cb1 --- /dev/null +++ b/src/core/file_sys/meta_file_system.cpp @@ -0,0 +1,520 @@ +// 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 +#include +#include "string_util.h" +#include "file_sys/meta_file_system.h" +//#include "Core/HLE/sceKernelThread.h" +//#include "Core/Reporting.h" + +static bool ApplyPathStringToComponentsVector(std::vector &vector, const std::string &pathString) +{ + size_t len = pathString.length(); + size_t start = 0; + + while (start < len) + { + size_t i = pathString.find('/', start); + if (i == std::string::npos) + i = len; + + if (i > start) + { + std::string component = pathString.substr(start, i - start); + if (component != ".") + { + if (component == "..") + { + if (vector.size() != 0) + { + vector.pop_back(); + } + else + { + // The PSP silently ignores attempts to .. to parent of root directory + WARN_LOG(FILESYS, "RealPath: ignoring .. beyond root - root directory is its own parent: \"%s\"", pathString.c_str()); + } + } + else + { + vector.push_back(component); + } + } + } + + start = i + 1; + } + + return true; +} + +/* + * Changes relative paths to absolute, removes ".", "..", and trailing "/" + * "drive:./blah" is absolute (ignore the dot) and "/blah" is relative (because it's missing "drive:") + * babel (and possibly other games) use "/directoryThatDoesNotExist/../directoryThatExists/filename" + */ +static bool RealPath(const std::string ¤tDirectory, const std::string &inPath, std::string &outPath) +{ + size_t inLen = inPath.length(); + if (inLen == 0) + { + WARN_LOG(FILESYS, "RealPath: inPath is empty"); + outPath = currentDirectory; + return true; + } + + size_t inColon = inPath.find(':'); + if (inColon + 1 == inLen) + { + // There's nothing after the colon, e.g. umd0: - this is perfectly valid. + outPath = inPath; + return true; + } + + bool relative = (inColon == std::string::npos); + + std::string prefix, inAfterColon; + std::vector cmpnts; // path components + size_t outPathCapacityGuess = inPath.length(); + + if (relative) + { + size_t curDirLen = currentDirectory.length(); + if (curDirLen == 0) + { + ERROR_LOG(FILESYS, "RealPath: inPath \"%s\" is relative, but current directory is empty", inPath.c_str()); + return false; + } + + size_t curDirColon = currentDirectory.find(':'); + if (curDirColon == std::string::npos) + { + ERROR_LOG(FILESYS, "RealPath: inPath \"%s\" is relative, but current directory \"%s\" has no prefix", inPath.c_str(), currentDirectory.c_str()); + return false; + } + if (curDirColon + 1 == curDirLen) + { + ERROR_LOG(FILESYS, "RealPath: inPath \"%s\" is relative, but current directory \"%s\" is all prefix and no path. Using \"/\" as path for current directory.", inPath.c_str(), currentDirectory.c_str()); + } + else + { + const std::string curDirAfter = currentDirectory.substr(curDirColon + 1); + if (! ApplyPathStringToComponentsVector(cmpnts, curDirAfter) ) + { + ERROR_LOG(FILESYS,"RealPath: currentDirectory is not a valid path: \"%s\"", currentDirectory.c_str()); + return false; + } + + outPathCapacityGuess += curDirLen; + } + + prefix = currentDirectory.substr(0, curDirColon + 1); + inAfterColon = inPath; + } + else + { + prefix = inPath.substr(0, inColon + 1); + inAfterColon = inPath.substr(inColon + 1); + } + + // Special case: "disc0:" is different from "disc0:/", so keep track of the single slash. + if (inAfterColon == "/") + { + outPath = prefix + inAfterColon; + return true; + } + + if (! ApplyPathStringToComponentsVector(cmpnts, inAfterColon) ) + { + WARN_LOG(FILESYS, "RealPath: inPath is not a valid path: \"%s\"", inPath.c_str()); + return false; + } + + outPath.clear(); + outPath.reserve(outPathCapacityGuess); + + outPath.append(prefix); + + size_t numCmpnts = cmpnts.size(); + for (size_t i = 0; i < numCmpnts; i++) + { + outPath.append(1, '/'); + outPath.append(cmpnts[i]); + } + + return true; +} + +IFileSystem *MetaFileSystem::GetHandleOwner(u32 handle) +{ + std::lock_guard guard(lock); + for (size_t i = 0; i < fileSystems.size(); i++) + { + if (fileSystems[i].system->OwnsHandle(handle)) + return fileSystems[i].system; //got it! + } + //none found? + return 0; +} + +bool MetaFileSystem::MapFilePath(const std::string &_inpath, std::string &outpath, MountPoint **system) +{ + std::lock_guard guard(lock); + std::string realpath; + + // Special handling: host0:command.txt (as seen in Super Monkey Ball Adventures, for example) + // appears to mean the current directory on the UMD. Let's just assume the current directory. + std::string inpath = _inpath; + if (strncasecmp(inpath.c_str(), "host0:", strlen("host0:")) == 0) { + INFO_LOG(FILESYS, "Host0 path detected, stripping: %s", inpath.c_str()); + inpath = inpath.substr(strlen("host0:")); + } + + const std::string *currentDirectory = &startingDirectory; + + _assert_msg_(FILESYS, false, "must implement equiv of __KernelGetCurThread"); + + int currentThread = 0;//__KernelGetCurThread(); + currentDir_t::iterator it = currentDir.find(currentThread); + if (it == currentDir.end()) + { + //Attempt to emulate SCE_KERNEL_ERROR_NOCWD / 8002032C: may break things requiring fixes elsewhere + if (inpath.find(':') == std::string::npos /* means path is relative */) + { + lastOpenError = -1;//SCE_KERNEL_ERROR_NOCWD; + WARN_LOG(FILESYS, "Path is relative, but current directory not set for thread %i. returning 8002032C(SCE_KERNEL_ERROR_NOCWD) instead.", currentThread); + } + } + else + { + currentDirectory = &(it->second); + } + + if ( RealPath(*currentDirectory, inpath, realpath) ) + { + for (size_t i = 0; i < fileSystems.size(); i++) + { + size_t prefLen = fileSystems[i].prefix.size(); + if (strncasecmp(fileSystems[i].prefix.c_str(), realpath.c_str(), prefLen) == 0) + { + outpath = realpath.substr(prefLen); + *system = &(fileSystems[i]); + + INFO_LOG(FILESYS, "MapFilePath: mapped \"%s\" to prefix: \"%s\", path: \"%s\"", inpath.c_str(), fileSystems[i].prefix.c_str(), outpath.c_str()); + + return true; + } + } + } + + DEBUG_LOG(FILESYS, "MapFilePath: failed mapping \"%s\", returning false", inpath.c_str()); + return false; +} + +void MetaFileSystem::Mount(std::string prefix, IFileSystem *system) +{ + std::lock_guard guard(lock); + MountPoint x; + x.prefix = prefix; + x.system = system; + fileSystems.push_back(x); +} + +void MetaFileSystem::Unmount(std::string prefix, IFileSystem *system) +{ + std::lock_guard guard(lock); + MountPoint x; + x.prefix = prefix; + x.system = system; + fileSystems.erase(std::remove(fileSystems.begin(), fileSystems.end(), x), fileSystems.end()); +} + +void MetaFileSystem::Shutdown() +{ + std::lock_guard guard(lock); + current = 6; + + // Ownership is a bit convoluted. Let's just delete everything once. + + std::set toDelete; + for (size_t i = 0; i < fileSystems.size(); i++) { + toDelete.insert(fileSystems[i].system); + } + + for (auto iter = toDelete.begin(); iter != toDelete.end(); ++iter) + { + delete *iter; + } + + fileSystems.clear(); + currentDir.clear(); + startingDirectory = ""; +} + +u32 MetaFileSystem::OpenWithError(int &error, std::string filename, FileAccess access, const char *devicename) +{ + std::lock_guard guard(lock); + u32 h = OpenFile(filename, access, devicename); + error = lastOpenError; + return h; +} + +u32 MetaFileSystem::OpenFile(std::string filename, FileAccess access, const char *devicename) +{ + std::lock_guard guard(lock); + lastOpenError = 0; + std::string of; + MountPoint *mount; + if (MapFilePath(filename, of, &mount)) + { + return mount->system->OpenFile(of, access, mount->prefix.c_str()); + } + else + { + return 0; + } +} + +FileInfo MetaFileSystem::GetFileInfo(std::string filename) +{ + std::lock_guard guard(lock); + std::string of; + IFileSystem *system; + if (MapFilePath(filename, of, &system)) + { + return system->GetFileInfo(of); + } + else + { + FileInfo bogus; // TODO + return bogus; + } +} + +bool MetaFileSystem::GetHostPath(const std::string &inpath, std::string &outpath) +{ + std::lock_guard guard(lock); + std::string of; + IFileSystem *system; + if (MapFilePath(inpath, of, &system)) { + return system->GetHostPath(of, outpath); + } else { + return false; + } +} + +std::vector MetaFileSystem::GetDirListing(std::string path) +{ + std::lock_guard guard(lock); + std::string of; + IFileSystem *system; + if (MapFilePath(path, of, &system)) + { + return system->GetDirListing(of); + } + else + { + std::vector empty; + return empty; + } +} + +void MetaFileSystem::ThreadEnded(int threadID) +{ + std::lock_guard guard(lock); + currentDir.erase(threadID); +} + +int MetaFileSystem::ChDir(const std::string &dir) +{ + std::lock_guard guard(lock); + // Retain the old path and fail if the arg is 1023 bytes or longer. + if (dir.size() >= 1023) + return -1;//SCE_KERNEL_ERROR_NAMETOOLONG; + + _assert_msg_(FILESYS, false, "must implement equiv of __KernelGetCurThread"); + + int curThread = 0; //__KernelGetCurThread(); + + std::string of; + MountPoint *mountPoint; + if (MapFilePath(dir, of, &mountPoint)) + { + currentDir[curThread] = mountPoint->prefix + of; + return 0; + } + else + { + for (size_t i = 0; i < fileSystems.size(); i++) + { + const std::string &prefix = fileSystems[i].prefix; + if (strncasecmp(prefix.c_str(), dir.c_str(), prefix.size()) == 0) + { + // The PSP is completely happy with invalid current dirs as long as they have a valid device. + WARN_LOG(FILESYS, "ChDir failed to map path \"%s\", saving as current directory anyway", dir.c_str()); + currentDir[curThread] = dir; + return 0; + } + } + + WARN_LOG(FILESYS, "ChDir failed to map device for \"%s\", failing", dir.c_str()); + return -1;//SCE_KERNEL_ERROR_NODEV; + } +} + +bool MetaFileSystem::MkDir(const std::string &dirname) +{ + std::lock_guard guard(lock); + std::string of; + IFileSystem *system; + if (MapFilePath(dirname, of, &system)) + { + return system->MkDir(of); + } + else + { + return false; + } +} + +bool MetaFileSystem::RmDir(const std::string &dirname) +{ + std::lock_guard guard(lock); + std::string of; + IFileSystem *system; + if (MapFilePath(dirname, of, &system)) + { + return system->RmDir(of); + } + else + { + return false; + } +} + +int MetaFileSystem::RenameFile(const std::string &from, const std::string &to) +{ + std::lock_guard guard(lock); + std::string of; + std::string rf; + IFileSystem *osystem; + IFileSystem *rsystem = NULL; + if (MapFilePath(from, of, &osystem)) + { + // If it's a relative path, it seems to always use from's filesystem. + if (to.find(":/") != to.npos) + { + if (!MapFilePath(to, rf, &rsystem)) + return -1; + } + else + { + rf = to; + rsystem = osystem; + } + + if (osystem != rsystem) + return -1;//SCE_KERNEL_ERROR_XDEV; + + return osystem->RenameFile(of, rf); + } + else + { + return -1; + } +} + +bool MetaFileSystem::RemoveFile(const std::string &filename) +{ + std::lock_guard guard(lock); + std::string of; + IFileSystem *system; + if (MapFilePath(filename, of, &system)) + { + return system->RemoveFile(of); + } + else + { + return false; + } +} + +void MetaFileSystem::CloseFile(u32 handle) +{ + std::lock_guard guard(lock); + IFileSystem *sys = GetHandleOwner(handle); + if (sys) + sys->CloseFile(handle); +} + +size_t MetaFileSystem::ReadFile(u32 handle, u8 *pointer, s64 size) +{ + std::lock_guard guard(lock); + IFileSystem *sys = GetHandleOwner(handle); + if (sys) + return sys->ReadFile(handle,pointer,size); + else + return 0; +} + +size_t MetaFileSystem::WriteFile(u32 handle, const u8 *pointer, s64 size) +{ + std::lock_guard guard(lock); + IFileSystem *sys = GetHandleOwner(handle); + if (sys) + return sys->WriteFile(handle,pointer,size); + else + return 0; +} + +size_t MetaFileSystem::SeekFile(u32 handle, s32 position, FileMove type) +{ + std::lock_guard guard(lock); + IFileSystem *sys = GetHandleOwner(handle); + if (sys) + return sys->SeekFile(handle,position,type); + else + return 0; +} + +void MetaFileSystem::DoState(PointerWrap &p) +{ + std::lock_guard guard(lock); + + auto s = p.Section("MetaFileSystem", 1); + if (!s) + return; + + p.Do(current); + + // Save/load per-thread current directory map + p.Do(currentDir); + + u32 n = (u32) fileSystems.size(); + p.Do(n); + if (n != (u32) fileSystems.size()) + { + p.SetError(p.ERROR_FAILURE); + ERROR_LOG(FILESYS, "Savestate failure: number of filesystems doesn't match."); + return; + } + + for (u32 i = 0; i < n; ++i) + fileSystems[i].system->DoState(p); +} + diff --git a/src/core/file_sys/meta_file_system.h b/src/core/file_sys/meta_file_system.h new file mode 100644 index 00000000..0de23d49 --- /dev/null +++ b/src/core/file_sys/meta_file_system.h @@ -0,0 +1,109 @@ +// 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 "std_mutex.h" +#include "file_sys.h" + +class MetaFileSystem : public IHandleAllocator, public IFileSystem +{ +private: + u32 current; + struct MountPoint + { + std::string prefix; + IFileSystem *system; + + bool operator == (const MountPoint &other) const + { + return prefix == other.prefix && system == other.system; + } + }; + std::vector fileSystems; + + typedef std::map currentDir_t; + currentDir_t currentDir; + + std::string startingDirectory; + int lastOpenError; + std::recursive_mutex lock; + +public: + MetaFileSystem() + { + current = 6; // what? + } + + void Mount(std::string prefix, IFileSystem *system); + void Unmount(std::string prefix, IFileSystem *system); + + void ThreadEnded(int threadID); + + void Shutdown(); + + u32 GetNewHandle() {return current++;} + void FreeHandle(u32 handle) {} + + virtual void DoState(PointerWrap &p); + + IFileSystem *GetHandleOwner(u32 handle); + bool MapFilePath(const std::string &inpath, std::string &outpath, MountPoint **system); + + inline bool MapFilePath(const std::string &_inpath, std::string &outpath, IFileSystem **system) + { + MountPoint *mountPoint; + if (MapFilePath(_inpath, outpath, &mountPoint)) + { + *system = mountPoint->system; + return true; + } + + return false; + } + + // Only possible if a file system is a DirectoryFileSystem or similar. + bool GetHostPath(const std::string &inpath, std::string &outpath); + + std::vector GetDirListing(std::string path); + u32 OpenFile(std::string filename, FileAccess access, const char *devicename = NULL); + u32 OpenWithError(int &error, 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); + FileInfo GetFileInfo(std::string filename); + bool OwnsHandle(u32 handle) {return false;} + inline size_t GetSeekPos(u32 handle) + { + return SeekFile(handle, 0, FILEMOVE_CURRENT); + } + + virtual int ChDir(const std::string &dir); + + virtual bool MkDir(const std::string &dirname); + virtual bool RmDir(const std::string &dirname); + virtual int RenameFile(const std::string &from, const std::string &to); + virtual bool RemoveFile(const std::string &filename); + + // TODO: void IoCtl(...) + + void SetStartingDirectory(const std::string &dir) { + std::lock_guard guard(lock); + startingDirectory = dir; + } +}; -- cgit v1.2.3