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
-
32src/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
-
106src/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