Browse Source
Merge pull request #26 from bunnei/romfs-archive
Merge pull request #26 from bunnei/romfs-archive
Adds preliminary RomFS archive supportpull/15/merge
bunnei
12 years ago
27 changed files with 807 additions and 1839 deletions
-
2src/citra_qt/main.cpp
-
12src/core/CMakeLists.txt
-
12src/core/core.vcxproj
-
36src/core/core.vcxproj.filters
-
54src/core/file_sys/archive.h
-
46src/core/file_sys/archive_romfs.cpp
-
50src/core/file_sys/archive_romfs.h
-
669src/core/file_sys/directory_file_system.cpp
-
155src/core/file_sys/directory_file_system.h
-
138src/core/file_sys/file_sys.h
-
519src/core/file_sys/meta_file_system.cpp
-
110src/core/file_sys/meta_file_system.h
-
157src/core/hle/kernel/archive.cpp
-
38src/core/hle/kernel/archive.h
-
3src/core/hle/kernel/kernel.cpp
-
1src/core/hle/kernel/kernel.h
-
164src/core/hle/service/apt.cpp
-
148src/core/hle/service/fs.cpp
-
31src/core/hle/service/fs.h
-
2src/core/hle/service/service.cpp
-
6src/core/loader/elf.h
-
15src/core/loader/loader.cpp
-
55src/core/loader/loader.h
-
172src/core/loader/ncch.cpp
-
47src/core/loader/ncch.h
-
2src/core/system.cpp
-
2src/core/system.h
@ -0,0 +1,54 @@ |
|||
// Copyright 2014 Citra Emulator Project |
|||
// Licensed under GPLv2 |
|||
// Refer to the license.txt file included. |
|||
|
|||
#pragma once |
|||
|
|||
#include "common/common_types.h" |
|||
|
|||
#include "core/hle/kernel/kernel.h" |
|||
|
|||
//////////////////////////////////////////////////////////////////////////////////////////////////// |
|||
// FileSys namespace |
|||
|
|||
namespace FileSys { |
|||
|
|||
class Archive : NonCopyable { |
|||
public: |
|||
/// Supported archive types |
|||
enum class IdCode : u32 { |
|||
RomFS = 0x00000003, |
|||
SaveData = 0x00000004, |
|||
ExtSaveData = 0x00000006, |
|||
SharedExtSaveData = 0x00000007, |
|||
SystemSaveData = 0x00000008, |
|||
SDMC = 0x00000009, |
|||
SDMCWriteOnly = 0x0000000A, |
|||
}; |
|||
|
|||
Archive() { } |
|||
virtual ~Archive() { } |
|||
|
|||
/** |
|||
* Get the IdCode of the archive (e.g. RomFS, SaveData, etc.) |
|||
* @return IdCode of the archive |
|||
*/ |
|||
virtual IdCode GetIdCode() const = 0; |
|||
|
|||
/** |
|||
* Read data from the archive |
|||
* @param offset Offset in bytes to start reading archive from |
|||
* @param length Length in bytes to read data from archive |
|||
* @param buffer Buffer to read data into |
|||
* @return Number of bytes read |
|||
*/ |
|||
virtual size_t Read(const u64 offset, const u32 length, u8* buffer) const = 0; |
|||
|
|||
/** |
|||
* Get the size of the archive in bytes |
|||
* @return Size of the archive in bytes |
|||
*/ |
|||
virtual size_t GetSize() const = 0; |
|||
}; |
|||
|
|||
} // namespace FileSys |
|||
@ -0,0 +1,46 @@ |
|||
// Copyright 2014 Citra Emulator Project
|
|||
// Licensed under GPLv2
|
|||
// Refer to the license.txt file included.
|
|||
|
|||
#include "common/common_types.h"
|
|||
|
|||
#include "core/file_sys/archive_romfs.h"
|
|||
|
|||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|||
// FileSys namespace
|
|||
|
|||
namespace FileSys { |
|||
|
|||
Archive_RomFS::Archive_RomFS(const Loader::AppLoader& app_loader) { |
|||
// Load the RomFS from the app
|
|||
if (Loader::ResultStatus::Success != app_loader.ReadRomFS(raw_data)) { |
|||
WARN_LOG(FILESYS, "Unable to read RomFS!"); |
|||
} |
|||
} |
|||
|
|||
Archive_RomFS::~Archive_RomFS() { |
|||
} |
|||
|
|||
/**
|
|||
* Read data from the archive |
|||
* @param offset Offset in bytes to start reading archive from |
|||
* @param length Length in bytes to read data from archive |
|||
* @param buffer Buffer to read data into |
|||
* @return Number of bytes read |
|||
*/ |
|||
size_t Archive_RomFS::Read(const u64 offset, const u32 length, u8* buffer) const { |
|||
DEBUG_LOG(FILESYS, "called offset=%d, length=%d", offset, length); |
|||
memcpy(buffer, &raw_data[(u32)offset], length); |
|||
return length; |
|||
} |
|||
|
|||
/**
|
|||
* Get the size of the archive in bytes |
|||
* @return Size of the archive in bytes |
|||
*/ |
|||
size_t Archive_RomFS::GetSize() const { |
|||
ERROR_LOG(FILESYS, "(UNIMPLEMENTED)"); |
|||
return 0; |
|||
} |
|||
|
|||
} // namespace FileSys
|
|||
@ -0,0 +1,50 @@ |
|||
// Copyright 2014 Citra Emulator Project |
|||
// Licensed under GPLv2 |
|||
// Refer to the license.txt file included. |
|||
|
|||
#pragma once |
|||
|
|||
#include <vector> |
|||
|
|||
#include "common/common_types.h" |
|||
|
|||
#include "core/file_sys/archive.h" |
|||
#include "core/loader/loader.h" |
|||
|
|||
//////////////////////////////////////////////////////////////////////////////////////////////////// |
|||
// FileSys namespace |
|||
|
|||
namespace FileSys { |
|||
|
|||
/// File system interface to the RomFS archive |
|||
class Archive_RomFS final : public Archive { |
|||
public: |
|||
Archive_RomFS(const Loader::AppLoader& app_loader); |
|||
~Archive_RomFS() override; |
|||
|
|||
/** |
|||
* Get the IdCode of the archive (e.g. RomFS, SaveData, etc.) |
|||
* @return IdCode of the archive |
|||
*/ |
|||
IdCode GetIdCode() const override { return IdCode::RomFS; }; |
|||
|
|||
/** |
|||
* Read data from the archive |
|||
* @param offset Offset in bytes to start reading archive from |
|||
* @param length Length in bytes to read data from archive |
|||
* @param buffer Buffer to read data into |
|||
* @return Number of bytes read |
|||
*/ |
|||
size_t Read(const u64 offset, const u32 length, u8* buffer) const override; |
|||
|
|||
/** |
|||
* Get the size of the archive in bytes |
|||
* @return Size of the archive in bytes |
|||
*/ |
|||
size_t GetSize() const override; |
|||
|
|||
private: |
|||
std::vector<u8> raw_data; |
|||
}; |
|||
|
|||
} // namespace FileSys |
|||
@ -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,138 +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/common.h" |
|||
#include "common/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<FileInfo> 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<FileInfo> GetDirListing(std::string path) {std::vector<FileInfo> 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;} |
|||
}; |
|||
|
|||
|
|||
@ -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; |
|||
} |
|||
}; |
|||
@ -0,0 +1,157 @@ |
|||
// Copyright 2014 Citra Emulator Project
|
|||
// Licensed under GPLv2
|
|||
// Refer to the license.txt file included.
|
|||
|
|||
#include "common/common_types.h"
|
|||
|
|||
#include "core/file_sys/archive.h"
|
|||
#include "core/hle/service/service.h"
|
|||
#include "core/hle/kernel/kernel.h"
|
|||
#include "core/hle/kernel/archive.h"
|
|||
|
|||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|||
// Kernel namespace
|
|||
|
|||
namespace Kernel { |
|||
|
|||
// Command to access archive file
|
|||
enum class FileCommand : u32 { |
|||
Dummy1 = 0x000100C6, |
|||
Control = 0x040100C4, |
|||
OpenSubFile = 0x08010100, |
|||
Read = 0x080200C2, |
|||
Write = 0x08030102, |
|||
GetSize = 0x08040000, |
|||
SetSize = 0x08050080, |
|||
GetAttributes = 0x08060000, |
|||
SetAttributes = 0x08070040, |
|||
Close = 0x08080000, |
|||
Flush = 0x08090000, |
|||
}; |
|||
|
|||
class Archive : public Object { |
|||
public: |
|||
const char* GetTypeName() const { return "Archive"; } |
|||
const char* GetName() const { return name.c_str(); } |
|||
|
|||
static Kernel::HandleType GetStaticHandleType() { return HandleType::Archive; } |
|||
Kernel::HandleType GetHandleType() const { return HandleType::Archive; } |
|||
|
|||
std::string name; ///< Name of archive (optional)
|
|||
FileSys::Archive* backend; ///< Archive backend interface
|
|||
|
|||
/**
|
|||
* Synchronize kernel object |
|||
* @param wait Boolean wait set if current thread should wait as a result of sync operation |
|||
* @return Result of operation, 0 on success, otherwise error code |
|||
*/ |
|||
Result SyncRequest(bool* wait) { |
|||
u32* cmd_buff = Service::GetCommandBuffer(); |
|||
FileCommand cmd = static_cast<FileCommand>(cmd_buff[0]); |
|||
switch (cmd) { |
|||
|
|||
// Read from archive...
|
|||
case FileCommand::Read: |
|||
{ |
|||
u64 offset = cmd_buff[1] | ((u64) cmd_buff[2]) << 32; |
|||
u32 length = cmd_buff[3]; |
|||
u32 address = cmd_buff[5]; |
|||
cmd_buff[2] = backend->Read(offset, length, Memory::GetPointer(address)); |
|||
break; |
|||
} |
|||
|
|||
// Unknown command...
|
|||
default: |
|||
ERROR_LOG(KERNEL, "Unknown command=0x%08X!", cmd); |
|||
return -1; |
|||
} |
|||
cmd_buff[1] = 0; // No error
|
|||
return 0; |
|||
} |
|||
|
|||
/**
|
|||
* Wait for kernel object to synchronize |
|||
* @param wait Boolean wait set if current thread should wait as a result of sync operation |
|||
* @return Result of operation, 0 on success, otherwise error code |
|||
*/ |
|||
Result WaitSynchronization(bool* wait) { |
|||
// TODO(bunnei): ImplementMe
|
|||
ERROR_LOG(OSHLE, "(UNIMPLEMENTED)"); |
|||
return 0; |
|||
} |
|||
}; |
|||
|
|||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|||
|
|||
std::map<FileSys::Archive::IdCode, Handle> g_archive_map; ///< Map of file archives by IdCode
|
|||
|
|||
/**
|
|||
* Opens an archive |
|||
* @param id_code IdCode of the archive to open |
|||
* @return Handle to archive if it exists, otherwise a null handle (0) |
|||
*/ |
|||
Handle OpenArchive(FileSys::Archive::IdCode id_code) { |
|||
auto itr = g_archive_map.find(id_code); |
|||
if (itr == g_archive_map.end()) { |
|||
return 0; |
|||
} |
|||
return itr->second; |
|||
} |
|||
|
|||
/**
|
|||
* Mounts an archive |
|||
* @param archive Pointer to the archive to mount |
|||
* @return Result of operation, 0 on success, otherwise error code |
|||
*/ |
|||
Result MountArchive(Archive* archive) { |
|||
FileSys::Archive::IdCode id_code = archive->backend->GetIdCode(); |
|||
if (0 != OpenArchive(id_code)) { |
|||
ERROR_LOG(KERNEL, "Cannot mount two archives with the same ID code! (%d)", (int) id_code); |
|||
return -1; |
|||
} |
|||
g_archive_map[id_code] = archive->GetHandle(); |
|||
INFO_LOG(KERNEL, "Mounted archive %s", archive->GetName()); |
|||
return 0; |
|||
} |
|||
|
|||
/**
|
|||
* Creates an Archive |
|||
* @param handle Handle to newly created archive object |
|||
* @param backend File system backend interface to the archive |
|||
* @param name Optional name of Archive |
|||
* @return Newly created Archive object |
|||
*/ |
|||
Archive* CreateArchive(Handle& handle, FileSys::Archive* backend, const std::string& name) { |
|||
Archive* archive = new Archive; |
|||
handle = Kernel::g_object_pool.Create(archive); |
|||
archive->name = name; |
|||
archive->backend = backend; |
|||
|
|||
MountArchive(archive); |
|||
|
|||
return archive; |
|||
} |
|||
|
|||
/**
|
|||
* Creates an Archive |
|||
* @param backend File system backend interface to the archive |
|||
* @param name Optional name of Archive |
|||
* @return Handle to newly created Archive object |
|||
*/ |
|||
Handle CreateArchive(FileSys::Archive* backend, const std::string& name) { |
|||
Handle handle; |
|||
Archive* archive = CreateArchive(handle, backend, name); |
|||
return handle; |
|||
} |
|||
|
|||
/// Initialize archives
|
|||
void ArchiveInit() { |
|||
g_archive_map.clear(); |
|||
} |
|||
|
|||
/// Shutdown archives
|
|||
void ArchiveShutdown() { |
|||
g_archive_map.clear(); |
|||
} |
|||
|
|||
} // namespace Kernel
|
|||
@ -0,0 +1,38 @@ |
|||
// Copyright 2014 Citra Emulator Project |
|||
// Licensed under GPLv2 |
|||
// Refer to the license.txt file included. |
|||
|
|||
#pragma once |
|||
|
|||
#include "common/common_types.h" |
|||
|
|||
#include "core/hle/kernel/kernel.h" |
|||
#include "core/file_sys/archive.h" |
|||
|
|||
//////////////////////////////////////////////////////////////////////////////////////////////////// |
|||
// Kernel namespace |
|||
|
|||
namespace Kernel { |
|||
|
|||
/** |
|||
* Opens an archive |
|||
* @param id_code IdCode of the archive to open |
|||
* @return Handle to archive if it exists, otherwise a null handle (0) |
|||
*/ |
|||
Handle OpenArchive(FileSys::Archive::IdCode id_code); |
|||
|
|||
/** |
|||
* Creates an Archive |
|||
* @param backend File system backend interface to the archive |
|||
* @param name Optional name of Archive |
|||
* @return Handle to newly created Archive object |
|||
*/ |
|||
Handle CreateArchive(FileSys::Archive* backend, const std::string& name); |
|||
|
|||
/// Initialize archives |
|||
void ArchiveInit(); |
|||
|
|||
/// Shutdown archives |
|||
void ArchiveShutdown(); |
|||
|
|||
} // namespace FileSys |
|||
@ -0,0 +1,148 @@ |
|||
// Copyright 2014 Citra Emulator Project
|
|||
// Licensed under GPLv2
|
|||
// Refer to the license.txt file included.
|
|||
|
|||
#include "common/common.h"
|
|||
|
|||
#include "core/loader/loader.h"
|
|||
#include "core/hle/hle.h"
|
|||
#include "core/hle/service/fs.h"
|
|||
#include "core/hle/kernel/archive.h"
|
|||
|
|||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|||
// Namespace FS_User
|
|||
|
|||
namespace FS_User { |
|||
|
|||
void Initialize(Service::Interface* self) { |
|||
u32* cmd_buff = Service::GetCommandBuffer(); |
|||
cmd_buff[1] = 0; // No error
|
|||
DEBUG_LOG(KERNEL, "called"); |
|||
} |
|||
|
|||
void OpenFileDirectly(Service::Interface* self) { |
|||
u32* cmd_buff = Service::GetCommandBuffer(); |
|||
|
|||
FileSys::Archive::IdCode arch_id = static_cast<FileSys::Archive::IdCode>(cmd_buff[2]); |
|||
|
|||
// TODO(bunnei): Properly implement use of these...
|
|||
//u32 transaction = cmd_buff[1];
|
|||
//u32 arch_lowpath_type = cmd_buff[3];
|
|||
//u32 arch_lowpath_sz = cmd_buff[4];
|
|||
//u32 file_lowpath_type = cmd_buff[5];
|
|||
//u32 file_lowpath_sz = cmd_buff[6];
|
|||
//u32 flags = cmd_buff[7];
|
|||
//u32 attr = cmd_buff[8];
|
|||
//u32 arch_lowpath_desc = cmd_buff[9];
|
|||
//u32 arch_lowpath_ptr = cmd_buff[10];
|
|||
//u32 file_lowpath_desc = cmd_buff[11];
|
|||
//u32 file_lowpath_ptr = cmd_buff[12];
|
|||
|
|||
Handle handle = Kernel::OpenArchive(arch_id); |
|||
if (0 != handle) { |
|||
cmd_buff[1] = 0; // No error
|
|||
cmd_buff[3] = handle; |
|||
} |
|||
DEBUG_LOG(KERNEL, "called"); |
|||
} |
|||
|
|||
const Interface::FunctionInfo FunctionTable[] = { |
|||
{0x000100C6, nullptr, "Dummy1"}, |
|||
{0x040100C4, nullptr, "Control"}, |
|||
{0x08010002, Initialize, "Initialize"}, |
|||
{0x080201C2, nullptr, "OpenFile"}, |
|||
{0x08030204, OpenFileDirectly, "OpenFileDirectly"}, |
|||
{0x08040142, nullptr, "DeleteFile"}, |
|||
{0x08050244, nullptr, "RenameFile"}, |
|||
{0x08060142, nullptr, "DeleteDirectory"}, |
|||
{0x08070142, nullptr, "DeleteDirectoryRecursively"}, |
|||
{0x08080202, nullptr, "CreateFile"}, |
|||
{0x08090182, nullptr, "CreateDirectory"}, |
|||
{0x080A0244, nullptr, "RenameDirectory"}, |
|||
{0x080B0102, nullptr, "OpenDirectory"}, |
|||
{0x080C00C2, nullptr, "OpenArchive"}, |
|||
{0x080D0144, nullptr, "ControlArchive"}, |
|||
{0x080E0080, nullptr, "CloseArchive"}, |
|||
{0x080F0180, nullptr, "FormatThisUserSaveData"}, |
|||
{0x08100200, nullptr, "CreateSystemSaveData"}, |
|||
{0x08110040, nullptr, "DeleteSystemSaveData"}, |
|||
{0x08120080, nullptr, "GetFreeBytes"}, |
|||
{0x08130000, nullptr, "GetCardType"}, |
|||
{0x08140000, nullptr, "GetSdmcArchiveResource"}, |
|||
{0x08150000, nullptr, "GetNandArchiveResource"}, |
|||
{0x08160000, nullptr, "GetSdmcFatfsErro"}, |
|||
{0x08170000, nullptr, "IsSdmcDetected"}, |
|||
{0x08180000, nullptr, "IsSdmcWritable"}, |
|||
{0x08190042, nullptr, "GetSdmcCid"}, |
|||
{0x081A0042, nullptr, "GetNandCid"}, |
|||
{0x081B0000, nullptr, "GetSdmcSpeedInfo"}, |
|||
{0x081C0000, nullptr, "GetNandSpeedInfo"}, |
|||
{0x081D0042, nullptr, "GetSdmcLog"}, |
|||
{0x081E0042, nullptr, "GetNandLog"}, |
|||
{0x081F0000, nullptr, "ClearSdmcLog"}, |
|||
{0x08200000, nullptr, "ClearNandLog"}, |
|||
{0x08210000, nullptr, "CardSlotIsInserted"}, |
|||
{0x08220000, nullptr, "CardSlotPowerOn"}, |
|||
{0x08230000, nullptr, "CardSlotPowerOff"}, |
|||
{0x08240000, nullptr, "CardSlotGetCardIFPowerStatus"}, |
|||
{0x08250040, nullptr, "CardNorDirectCommand"}, |
|||
{0x08260080, nullptr, "CardNorDirectCommandWithAddress"}, |
|||
{0x08270082, nullptr, "CardNorDirectRead"}, |
|||
{0x082800C2, nullptr, "CardNorDirectReadWithAddress"}, |
|||
{0x08290082, nullptr, "CardNorDirectWrite"}, |
|||
{0x082A00C2, nullptr, "CardNorDirectWriteWithAddress"}, |
|||
{0x082B00C2, nullptr, "CardNorDirectRead_4xIO"}, |
|||
{0x082C0082, nullptr, "CardNorDirectCpuWriteWithoutVerify"}, |
|||
{0x082D0040, nullptr, "CardNorDirectSectorEraseWithoutVerify"}, |
|||
{0x082E0040, nullptr, "GetProductInfo"}, |
|||
{0x082F0040, nullptr, "GetProgramLaunchInfo"}, |
|||
{0x08300182, nullptr, "CreateExtSaveData"}, |
|||
{0x08310180, nullptr, "CreateSharedExtSaveData"}, |
|||
{0x08320102, nullptr, "ReadExtSaveDataIcon"}, |
|||
{0x08330082, nullptr, "EnumerateExtSaveData"}, |
|||
{0x08340082, nullptr, "EnumerateSharedExtSaveData"}, |
|||
{0x08350080, nullptr, "DeleteExtSaveData"}, |
|||
{0x08360080, nullptr, "DeleteSharedExtSaveData"}, |
|||
{0x08370040, nullptr, "SetCardSpiBaudRate"}, |
|||
{0x08380040, nullptr, "SetCardSpiBusMode"}, |
|||
{0x08390000, nullptr, "SendInitializeInfoTo9"}, |
|||
{0x083A0100, nullptr, "GetSpecialContentIndex"}, |
|||
{0x083B00C2, nullptr, "GetLegacyRomHeader"}, |
|||
{0x083C00C2, nullptr, "GetLegacyBannerData"}, |
|||
{0x083D0100, nullptr, "CheckAuthorityToAccessExtSaveData"}, |
|||
{0x083E00C2, nullptr, "QueryTotalQuotaSize"}, |
|||
{0x083F00C0, nullptr, "GetExtDataBlockSize"}, |
|||
{0x08400040, nullptr, "AbnegateAccessRight"}, |
|||
{0x08410000, nullptr, "DeleteSdmcRoot"}, |
|||
{0x08420040, nullptr, "DeleteAllExtSaveDataOnNand"}, |
|||
{0x08430000, nullptr, "InitializeCtrFileSystem"}, |
|||
{0x08440000, nullptr, "CreateSeed"}, |
|||
{0x084500C2, nullptr, "GetFormatInfo"}, |
|||
{0x08460102, nullptr, "GetLegacyRomHeader2"}, |
|||
{0x08470180, nullptr, "FormatCtrCardUserSaveData"}, |
|||
{0x08480042, nullptr, "GetSdmcCtrRootPath"}, |
|||
{0x08490040, nullptr, "GetArchiveResource"}, |
|||
{0x084A0002, nullptr, "ExportIntegrityVerificationSeed"}, |
|||
{0x084B0002, nullptr, "ImportIntegrityVerificationSeed"}, |
|||
{0x084C0242, nullptr, "FormatSaveData"}, |
|||
{0x084D0102, nullptr, "GetLegacySubBannerData"}, |
|||
{0x084E0342, nullptr, "UpdateSha256Context"}, |
|||
{0x084F0102, nullptr, "ReadSpecialFile"}, |
|||
{0x08500040, nullptr, "GetSpecialFileSize"}, |
|||
{0x08580000, nullptr, "GetMovableSedHashedKeyYRandomData"}, |
|||
{0x08610042, nullptr, "InitializeWithSdkVersion"}, |
|||
{0x08620040, nullptr, "SetPriority"}, |
|||
{0x08630000, nullptr, "GetPriority"}, |
|||
}; |
|||
|
|||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|||
// Interface class
|
|||
|
|||
Interface::Interface() { |
|||
Register(FunctionTable, ARRAY_SIZE(FunctionTable)); |
|||
} |
|||
|
|||
Interface::~Interface() { |
|||
} |
|||
|
|||
} // namespace
|
|||
@ -0,0 +1,31 @@ |
|||
// Copyright 2014 Citra Emulator Project |
|||
// Licensed under GPLv2 |
|||
// Refer to the license.txt file included. |
|||
|
|||
#pragma once |
|||
|
|||
#include "core/hle/service/service.h" |
|||
|
|||
//////////////////////////////////////////////////////////////////////////////////////////////////// |
|||
// Namespace FS_User |
|||
|
|||
namespace FS_User { |
|||
|
|||
/// Interface to "fs:USER" service |
|||
class Interface : public Service::Interface { |
|||
public: |
|||
|
|||
Interface(); |
|||
|
|||
~Interface(); |
|||
|
|||
/** |
|||
* Gets the string port name used by CTROS for the service |
|||
* @return Port name of service |
|||
*/ |
|||
const char *GetPortName() const { |
|||
return "Ufs:"; |
|||
} |
|||
}; |
|||
|
|||
} // namespace |
|||
Write
Preview
Loading…
Cancel
Save
Reference in new issue