Core: Removed unused directory_file_system and meta_file_system modules.
Core: Updated CMakeLists.txt to remove directory_file_system and meta_file_system modules.
This commit is contained in:
bunnei
parent
469fe42fad
commit
0cc3e85685
|
|
@ -29,8 +29,6 @@ set(SRCS core.cpp
|
|||
arm/interpreter/mmu/tlb.cpp
|
||||
arm/interpreter/mmu/wb.cpp
|
||||
arm/interpreter/mmu/xscale_copro.cpp
|
||||
file_sys/directory_file_system.cpp
|
||||
file_sys/meta_file_system.cpp
|
||||
hle/hle.cpp
|
||||
hle/config_mem.cpp
|
||||
hle/coprocessor.cpp
|
||||
|
|
@ -75,9 +73,7 @@ set(HEADERS core.h
|
|||
arm/interpreter/vfp/asm_vfp.h
|
||||
arm/interpreter/vfp/vfp.h
|
||||
arm/interpreter/vfp/vfp_helper.h
|
||||
file_sys/directory_file_system.h
|
||||
file_sys/file_sys.h
|
||||
file_sys/meta_file_system.h
|
||||
hle/config_mem.h
|
||||
hle/coprocessor.h
|
||||
hle/hle.h
|
||||
|
|
|
|||
|
|
@ -162,8 +162,6 @@
|
|||
<ClCompile Include="arm\interpreter\vfp\vfpsingle.cpp" />
|
||||
<ClCompile Include="core.cpp" />
|
||||
<ClCompile Include="core_timing.cpp" />
|
||||
<ClCompile Include="file_sys\directory_file_system.cpp" />
|
||||
<ClCompile Include="file_sys\meta_file_system.cpp" />
|
||||
<ClCompile Include="hle\config_mem.cpp" />
|
||||
<ClCompile Include="hle\coprocessor.cpp" />
|
||||
<ClCompile Include="hle\hle.cpp" />
|
||||
|
|
@ -211,9 +209,7 @@
|
|||
<ClInclude Include="arm\interpreter\vfp\vfp_helper.h" />
|
||||
<ClInclude Include="core.h" />
|
||||
<ClInclude Include="core_timing.h" />
|
||||
<ClInclude Include="file_sys\directory_file_system.h" />
|
||||
<ClInclude Include="file_sys\file_sys.h" />
|
||||
<ClInclude Include="file_sys\meta_file_system.h" />
|
||||
<ClInclude Include="hle\config_mem.h" />
|
||||
<ClInclude Include="hle\coprocessor.h" />
|
||||
<ClInclude Include="hle\function_wrappers.h" />
|
||||
|
|
|
|||
|
|
@ -63,12 +63,6 @@
|
|||
<ClCompile Include="arm\interpreter\thumbemu.cpp">
|
||||
<Filter>arm\interpreter</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="file_sys\directory_file_system.cpp">
|
||||
<Filter>file_sys</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="file_sys\meta_file_system.cpp">
|
||||
<Filter>file_sys</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="hw\hw.cpp">
|
||||
<Filter>hw</Filter>
|
||||
</ClCompile>
|
||||
|
|
@ -205,15 +199,9 @@
|
|||
<ClInclude Include="arm\interpreter\skyeye_defs.h">
|
||||
<Filter>arm\interpreter</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="file_sys\directory_file_system.h">
|
||||
<Filter>file_sys</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="file_sys\file_sys.h">
|
||||
<Filter>file_sys</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="file_sys\meta_file_system.h">
|
||||
<Filter>file_sys</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="hw\hw.h">
|
||||
<Filter>hw</Filter>
|
||||
</ClInclude>
|
||||
|
|
|
|||
|
|
@ -1,669 +0,0 @@
|
|||
// 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 "common/chunk_file.h"
|
||||
#include "common/file_util.h"
|
||||
#include "common/utf8.h"
|
||||
|
||||
#include "core/file_sys/directory_file_system.h"
|
||||
|
||||
#if EMU_PLATFORM == PLATFORM_WINDOWS
|
||||
#include <windows.h>
|
||||
#include <sys/stat.h>
|
||||
#else
|
||||
#include <dirent.h>
|
||||
#include <unistd.h>
|
||||
#include <sys/stat.h>
|
||||
#include <ctype.h>
|
||||
#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<FileInfo> DirectoryFileSystem::GetDirListing(std::string path) {
|
||||
std::vector<FileInfo> 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.");
|
||||
}
|
||||
}
|
||||
|
|
@ -1,155 +0,0 @@
|
|||
// 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
|
||||
|
||||
// TODO: Remove the Windows-specific code, FILE is fine there too.
|
||||
|
||||
#include <map>
|
||||
|
||||
#include "core/file_sys/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<FileInfo> 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<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<FileInfo> 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<u32, OpenFileEntry> EntryMap;
|
||||
EntryMap entries;
|
||||
std::string basePath;
|
||||
IHandleAllocator *hAlloc;
|
||||
|
||||
std::string GetLocalPath(std::string localpath);
|
||||
};
|
||||
|
|
@ -1,519 +0,0 @@
|
|||
// 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 <set>
|
||||
#include <algorithm>
|
||||
|
||||
#include "common/string_util.h"
|
||||
#include "core/file_sys/meta_file_system.h"
|
||||
|
||||
static bool ApplyPathStringToComponentsVector(std::vector<std::string> &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<std::string> 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<std::recursive_mutex> 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<std::recursive_mutex> 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<std::recursive_mutex> 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<std::recursive_mutex> 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<std::recursive_mutex> guard(lock);
|
||||
current = 6;
|
||||
|
||||
// Ownership is a bit convoluted. Let's just delete everything once.
|
||||
|
||||
std::set<IFileSystem *> 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<std::recursive_mutex> 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<std::recursive_mutex> 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<std::recursive_mutex> 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<std::recursive_mutex> guard(lock);
|
||||
std::string of;
|
||||
IFileSystem *system;
|
||||
if (MapFilePath(inpath, of, &system)) {
|
||||
return system->GetHostPath(of, outpath);
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
std::vector<FileInfo> MetaFileSystem::GetDirListing(std::string path)
|
||||
{
|
||||
std::lock_guard<std::recursive_mutex> guard(lock);
|
||||
std::string of;
|
||||
IFileSystem *system;
|
||||
if (MapFilePath(path, of, &system))
|
||||
{
|
||||
return system->GetDirListing(of);
|
||||
}
|
||||
else
|
||||
{
|
||||
std::vector<FileInfo> empty;
|
||||
return empty;
|
||||
}
|
||||
}
|
||||
|
||||
void MetaFileSystem::ThreadEnded(int threadID)
|
||||
{
|
||||
std::lock_guard<std::recursive_mutex> guard(lock);
|
||||
currentDir.erase(threadID);
|
||||
}
|
||||
|
||||
int MetaFileSystem::ChDir(const std::string &dir)
|
||||
{
|
||||
std::lock_guard<std::recursive_mutex> 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<std::recursive_mutex> 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<std::recursive_mutex> 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<std::recursive_mutex> 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<std::recursive_mutex> 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<std::recursive_mutex> guard(lock);
|
||||
IFileSystem *sys = GetHandleOwner(handle);
|
||||
if (sys)
|
||||
sys->CloseFile(handle);
|
||||
}
|
||||
|
||||
size_t MetaFileSystem::ReadFile(u32 handle, u8 *pointer, s64 size)
|
||||
{
|
||||
std::lock_guard<std::recursive_mutex> 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<std::recursive_mutex> 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<std::recursive_mutex> 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<std::recursive_mutex> 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);
|
||||
}
|
||||
|
||||
|
|
@ -1,110 +0,0 @@
|
|||
// 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/std_mutex.h"
|
||||
|
||||
#include "core/file_sys/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<MountPoint> fileSystems;
|
||||
|
||||
typedef std::map<int, std::string> 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<FileInfo> 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<std::recursive_mutex> guard(lock);
|
||||
startingDirectory = dir;
|
||||
}
|
||||
};
|
||||
|
|
@ -15,7 +15,6 @@
|
|||
namespace System {
|
||||
|
||||
volatile State g_state;
|
||||
MetaFileSystem g_ctr_file_system;
|
||||
|
||||
void UpdateState(State state) {
|
||||
}
|
||||
|
|
@ -45,7 +44,6 @@ void Shutdown() {
|
|||
CoreTiming::Shutdown();
|
||||
VideoCore::Shutdown();
|
||||
Kernel::Shutdown();
|
||||
g_ctr_file_system.Shutdown();
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
|
|
|||
|
|
@ -5,7 +5,6 @@
|
|||
#pragma once
|
||||
|
||||
#include "common/emu_window.h"
|
||||
#include "core/file_sys/meta_file_system.h"
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
|
@ -24,7 +23,6 @@ typedef enum {
|
|||
} State;
|
||||
|
||||
extern volatile State g_state;
|
||||
extern MetaFileSystem g_ctr_file_system;
|
||||
|
||||
void UpdateState(State state);
|
||||
void Init(EmuWindow* emu_window);
|
||||
|
|
|
|||
Reference in New Issue