mirrors/suyu
1
0
Fork 0
mirror of https://git.suyu.dev/suyu/suyu.git synced 2024-11-15 22:54:00 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge pull request #26 from bunnei/romfs-archive

Browse source 
Adds preliminary RomFS archive support
This commit is contained in:
bunnei 2014-07-04 21:58:08 -04:00
commit ad1adb2f92
27 changed files with 804 additions and 1836 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/citra_qt/main.cpp
View file

@ -152,7 +152,7 @@ void GMainWindow::BootGame(const char* filename)
void GMainWindow::OnMenuLoadFile()
{
QString filename = QFileDialog::getOpenFileName(this, tr("Load file"), QString(), tr("3DS homebrew (*.elf *.axf *.dat *.bin)"));
QString filename = QFileDialog::getOpenFileName(this, tr("Load file"), QString(), tr("3DS executable (*.elf *.axf *.cci *.cxi)"));
if (filename.size())
BootGame(filename.toLatin1().data());
}

12
src/core/CMakeLists.txt
View file

@ -8,6 +8,7 @@ set(SRCS core.cpp
system.cpp
arm/disassembler/arm_disasm.cpp
arm/disassembler/load_symbol_map.cpp
file_sys/archive_romfs.cpp
arm/interpreter/arm_interpreter.cpp
arm/interpreter/armcopro.cpp
arm/interpreter/armemu.cpp
@ -29,17 +30,17 @@ set(SRCS core.cpp
arm/interpreter/mmu/tlb.cpp
arm/interpreter/mmu/wb.cpp
arm/interpreter/mmu/xscale_copro.cpp
file_sys/directory_file_system.cpp
file_sys/meta_file_system.cpp
hle/hle.cpp
hle/config_mem.cpp
hle/coprocessor.cpp
hle/svc.cpp
hle/kernel/archive.cpp
hle/kernel/event.cpp
hle/kernel/kernel.cpp
hle/kernel/mutex.cpp
hle/kernel/thread.cpp
hle/service/apt.cpp
hle/service/fs.cpp
hle/service/gsp.cpp
hle/service/hid.cpp
hle/service/ndm.cpp
@ -75,18 +76,19 @@ set(HEADERS core.h
arm/interpreter/vfp/asm_vfp.h
arm/interpreter/vfp/vfp.h
arm/interpreter/vfp/vfp_helper.h
file_sys/directory_file_system.h
file_sys/file_sys.h
file_sys/meta_file_system.h
file_sys/archive.h
file_sys/archive_romfs.h
hle/config_mem.h
hle/coprocessor.h
hle/hle.h
hle/svc.h
hle/kernel/archive.h
hle/kernel/kernel.h
hle/kernel/mutex.h
hle/kernel/thread.h
hle/function_wrappers.h
hle/service/apt.h
hle/service/fs.h
hle/service/gsp.h
hle/service/hid.h
hle/service/service.h

12
src/core/core.vcxproj
View file

@ -162,16 +162,17 @@
<ClCompile Include="arm\interpreter\vfp\vfpsingle.cpp" />
<ClCompile Include="core.cpp" />
<ClCompile Include="core_timing.cpp" />
<ClCompile Include="file_sys\directory_file_system.cpp" />
<ClCompile Include="file_sys\meta_file_system.cpp" />
<ClCompile Include="file_sys\archive_romfs.cpp" />
<ClCompile Include="hle\config_mem.cpp" />
<ClCompile Include="hle\coprocessor.cpp" />
<ClCompile Include="hle\hle.cpp" />
<ClCompile Include="hle\kernel\archive.cpp" />
<ClCompile Include="hle\kernel\event.cpp" />
<ClCompile Include="hle\kernel\kernel.cpp" />
<ClCompile Include="hle\kernel\mutex.cpp" />
<ClCompile Include="hle\kernel\thread.cpp" />
<ClCompile Include="hle\service\apt.cpp" />
<ClCompile Include="hle\service\fs.cpp" />
<ClCompile Include="hle\service\gsp.cpp" />
<ClCompile Include="hle\service\hid.cpp" />
<ClCompile Include="hle\service\ndm.cpp" />
@ -211,18 +212,19 @@
<ClInclude Include="arm\interpreter\vfp\vfp_helper.h" />
<ClInclude Include="core.h" />
<ClInclude Include="core_timing.h" />
<ClInclude Include="file_sys\directory_file_system.h" />
<ClInclude Include="file_sys\file_sys.h" />
<ClInclude Include="file_sys\meta_file_system.h" />
<ClInclude Include="file_sys\archive.h" />
<ClInclude Include="file_sys\archive_romfs.h" />
<ClInclude Include="hle\config_mem.h" />
<ClInclude Include="hle\coprocessor.h" />
<ClInclude Include="hle\function_wrappers.h" />
<ClInclude Include="hle\hle.h" />
<ClInclude Include="hle\kernel\archive.h" />
<ClInclude Include="hle\kernel\event.h" />
<ClInclude Include="hle\kernel\kernel.h" />
<ClInclude Include="hle\kernel\mutex.h" />
<ClInclude Include="hle\kernel\thread.h" />
<ClInclude Include="hle\service\apt.h" />
<ClInclude Include="hle\service\fs.h" />
<ClInclude Include="hle\service\gsp.h" />
<ClInclude Include="hle\service\hid.h" />
<ClInclude Include="hle\service\ndm.h" />

36
src/core/core.vcxproj.filters
View file

@ -63,12 +63,6 @@
<ClCompile Include="arm\interpreter\thumbemu.cpp">
<Filter>arm\interpreter</Filter>
</ClCompile>
<ClCompile Include="file_sys\directory_file_system.cpp">
<Filter>file_sys</Filter>
</ClCompile>
<ClCompile Include="file_sys\meta_file_system.cpp">
<Filter>file_sys</Filter>
</ClCompile>
<ClCompile Include="hw\hw.cpp">
<Filter>hw</Filter>
</ClCompile>
@ -176,6 +170,15 @@
<ClCompile Include="loader\elf.cpp">
<Filter>loader</Filter>
</ClCompile>
<ClCompile Include="hle\kernel\archive.cpp">
<Filter>hle\kernel</Filter>
</ClCompile>
<ClCompile Include="hle\service\fs.cpp">
<Filter>hle\service</Filter>
</ClCompile>
<ClCompile Include="file_sys\archive_romfs.cpp">
<Filter>file_sys</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="arm\disassembler\arm_disasm.h">
@ -205,15 +208,6 @@
<ClInclude Include="arm\interpreter\skyeye_defs.h">
<Filter>arm\interpreter</Filter>
</ClInclude>
<ClInclude Include="file_sys\directory_file_system.h">
<Filter>file_sys</Filter>
</ClInclude>
<ClInclude Include="file_sys\file_sys.h">
<Filter>file_sys</Filter>
</ClInclude>
<ClInclude Include="file_sys\meta_file_system.h">
<Filter>file_sys</Filter>
</ClInclude>
<ClInclude Include="hw\hw.h">
<Filter>hw</Filter>
</ClInclude>
@ -314,6 +308,18 @@
<ClInclude Include="loader\elf.h">
<Filter>loader</Filter>
</ClInclude>
<ClInclude Include="hle\kernel\archive.h">
<Filter>hle\kernel</Filter>
</ClInclude>
<ClInclude Include="hle\service\fs.h">
<Filter>hle\service</Filter>
</ClInclude>
<ClInclude Include="file_sys\archive.h">
<Filter>file_sys</Filter>
</ClInclude>
<ClInclude Include="file_sys\archive_romfs.h">
<Filter>file_sys</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<Text Include="CMakeLists.txt" />

54
src/core/file_sys/archive.h Normal file
View file

@ -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

46
src/core/file_sys/archive_romfs.cpp Normal file
View file

@ -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

50
src/core/file_sys/archive_romfs.h Normal file
View file

@ -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

669
src/core/file_sys/directory_file_system.cpp
View file

@ -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.");
}
}

155
src/core/file_sys/directory_file_system.h
View file

@ -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);
};

138
src/core/file_sys/file_sys.h
View file

@ -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;}
};

519
src/core/file_sys/meta_file_system.cpp
View file

@ -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 &currentDirectory, 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);
}

110
src/core/file_sys/meta_file_system.h
View file

@ -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;
}
};

157
src/core/hle/kernel/archive.cpp Normal file
View file

@ -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

38
src/core/hle/kernel/archive.h Normal file
View file

@ -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

3
src/core/hle/kernel/kernel.cpp
View file

@ -9,6 +9,7 @@
#include "core/core.h"
#include "core/hle/kernel/kernel.h"
#include "core/hle/kernel/thread.h"
#include "core/hle/kernel/archive.h"
namespace Kernel {
@ -133,11 +134,13 @@ Object* ObjectPool::CreateByIDType(int type) {
/// Initialize the kernel
void Init() {
Kernel::ThreadingInit();
Kernel::ArchiveInit();
}
/// Shutdown the kernel
void Shutdown() {
Kernel::ThreadingShutdown();
Kernel::ArchiveShutdown();
g_object_pool.Clear(); // Free all kernel objects
}

1
src/core/hle/kernel/kernel.h
View file

@ -29,6 +29,7 @@ enum class HandleType : u32 {
Arbiter = 9,
File = 10,
Semaphore = 11,
Archive = 12,
};
enum {

164
src/core/hle/service/apt.cpp
View file

@ -15,9 +15,16 @@
namespace APT_U {
/// Signals used by APT functions
enum class SignalType : u32 {
None = 0x0,
AppJustStarted = 0x1,
ReturningToApp = 0xB,
ExitingApp = 0xC,
};
void Initialize(Service::Interface* self) {
u32* cmd_buff = Service::GetCommandBuffer();
DEBUG_LOG(KERNEL, "called");
cmd_buff[3] = Kernel::CreateEvent(RESETTYPE_ONESHOT, "APT_U:Menu"); // APT menu event handle
cmd_buff[4] = Kernel::CreateEvent(RESETTYPE_ONESHOT, "APT_U:Pause"); // APT pause event handle
@ -26,6 +33,7 @@ void Initialize(Service::Interface* self) {
Kernel::SetEventLocked(cmd_buff[4], false); // Fire start event
cmd_buff[1] = 0; // No error
DEBUG_LOG(KERNEL, "called");
}
void GetLockHandle(Service::Interface* self) {
@ -40,15 +48,29 @@ void Enable(Service::Interface* self) {
u32* cmd_buff = Service::GetCommandBuffer();
u32 unk = cmd_buff[1]; // TODO(bunnei): What is this field used for?
cmd_buff[1] = 0; // No error
ERROR_LOG(KERNEL, "(UNIMPEMENTED) called unk=0x%08X", unk);
WARN_LOG(KERNEL, "(STUBBED) called unk=0x%08X", unk);
}
void InquireNotification(Service::Interface* self) {
u32* cmd_buff = Service::GetCommandBuffer();
u32 app_id = cmd_buff[2];
cmd_buff[1] = 0; // No error
cmd_buff[3] = 0; // Signal type
ERROR_LOG(KERNEL, "(UNIMPEMENTED) called app_id=0x%08X", app_id);
cmd_buff[2] = static_cast<u32>(SignalType::None); // Signal type
WARN_LOG(KERNEL, "(STUBBED) called app_id=0x%08X", app_id);
}
void ReceiveParameter(Service::Interface* self) {
u32* cmd_buff = Service::GetCommandBuffer();
u32 app_id = cmd_buff[1];
u32 buffer_size = cmd_buff[2];
cmd_buff[1] = 0; // No error
cmd_buff[2] = 0;
cmd_buff[3] = static_cast<u32>(SignalType::AppJustStarted); // Signal type
cmd_buff[4] = 0x10;
cmd_buff[5] = 0;
cmd_buff[6] = 0;
cmd_buff[7] = 0;
WARN_LOG(KERNEL, "(STUBBED) called app_id=0x%08X, buffer_size=0x%08X", app_id, buffer_size);
}
const Interface::FunctionInfo FunctionTable[] = {
@ -63,73 +85,73 @@ const Interface::FunctionInfo FunctionTable[] = {
{0x00090040, nullptr, "IsRegistered"},
{0x000A0040, nullptr, "GetAttribute"},
{0x000B0040, InquireNotification, "InquireNotification"},
{0x000C0104, nullptr, "SendParameter"},
{0x000D0080, nullptr, "ReceiveParameter"},
{0x000E0080, nullptr, "GlanceParameter"},
{0x000F0100, nullptr, "CancelParameter"},
{0x001000C2, nullptr, "DebugFunc"},
{0x001100C0, nullptr, "MapProgramIdForDebug"},
{0x00120040, nullptr, "SetHomeMenuAppletIdForDebug"},
{0x00130000, nullptr, "GetPreparationState"},
{0x00140040, nullptr, "SetPreparationState"},
{0x00150140, nullptr, "PrepareToStartApplication"},
{0x00160040, nullptr, "PreloadLibraryApplet"},
{0x00170040, nullptr, "FinishPreloadingLibraryApplet"},
{0x00180040, nullptr, "PrepareToStartLibraryApplet"},
{0x00190040, nullptr, "PrepareToStartSystemApplet"},
{0x001A0000, nullptr, "PrepareToStartNewestHomeMenu"},
{0x001B00C4, nullptr, "StartApplication"},
{0x001C0000, nullptr, "WakeupApplication"},
{0x001D0000, nullptr, "CancelApplication"},
{0x001E0084, nullptr, "StartLibraryApplet"},
{0x001F0084, nullptr, "StartSystemApplet"},
{0x00200044, nullptr, "StartNewestHomeMenu"},
{0x00210000, nullptr, "OrderToCloseApplication"},
{0x00220040, nullptr, "PrepareToCloseApplication"},
{0x00230040, nullptr, "PrepareToJumpToApplication"},
{0x00240044, nullptr, "JumpToApplication"},
{0x002500C0, nullptr, "PrepareToCloseLibraryApplet"},
{0x00260000, nullptr, "PrepareToCloseSystemApplet"},
{0x00270044, nullptr, "CloseApplication"},
{0x00280044, nullptr, "CloseLibraryApplet"},
{0x00290044, nullptr, "CloseSystemApplet"},
{0x002A0000, nullptr, "OrderToCloseSystemApplet"},
{0x002B0000, nullptr, "PrepareToJumpToHomeMenu"},
{0x002C0044, nullptr, "JumpToHomeMenu"},
{0x002D0000, nullptr, "PrepareToLeaveHomeMenu"},
{0x002E0044, nullptr, "LeaveHomeMenu"},
{0x002F0040, nullptr, "PrepareToLeaveResidentApplet"},
{0x00300044, nullptr, "LeaveResidentApplet"},
{0x00310100, nullptr, "PrepareToDoApplicationJump"},
{0x00320084, nullptr, "DoApplicationJump"},
{0x00330000, nullptr, "GetProgramIdOnApplicationJump"},
{0x00340084, nullptr, "SendDeliverArg"},
{0x00350080, nullptr, "ReceiveDeliverArg"},
{0x00360040, nullptr, "LoadSysMenuArg"},
{0x00370042, nullptr, "StoreSysMenuArg"},
{0x00380040, nullptr, "PreloadResidentApplet"},
{0x00390040, nullptr, "PrepareToStartResidentApplet"},
{0x003A0044, nullptr, "StartResidentApplet"},
{0x003B0040, nullptr, "CancelLibraryApplet"},
{0x003C0042, nullptr, "SendDspSleep"},
{0x003D0042, nullptr, "SendDspWakeUp"},
{0x003E0080, nullptr, "ReplySleepQuery"},
{0x003F0040, nullptr, "ReplySleepNotificationComplete"},
{0x00400042, nullptr, "SendCaptureBufferInfo"},
{0x00410040, nullptr, "ReceiveCaptureBufferInfo"},
{0x00420080, nullptr, "SleepSystem"},
{0x00430040, nullptr, "NotifyToWait"},
{0x00440000, nullptr, "GetSharedFont"},
{0x00450040, nullptr, "GetWirelessRebootInfo"},
{0x00460104, nullptr, "Wrap"},
{0x00470104, nullptr, "Unwrap"},
{0x00480100, nullptr, "GetProgramInfo"},
{0x00490180, nullptr, "Reboot"},
{0x004A0040, nullptr, "GetCaptureInfo"},
{0x004B00C2, nullptr, "AppletUtility"},
{0x004C0000, nullptr, "SetFatalErrDispMode"},
{0x004D0080, nullptr, "GetAppletProgramInfo"},
{0x004E0000, nullptr, "HardwareResetAsync"},
{0x000C0104, nullptr, "SendParameter"},
{0x000D0080, ReceiveParameter, "ReceiveParameter"},
{0x000E0080, nullptr, "GlanceParameter"},
{0x000F0100, nullptr, "CancelParameter"},
{0x001000C2, nullptr, "DebugFunc"},
{0x001100C0, nullptr, "MapProgramIdForDebug"},
{0x00120040, nullptr, "SetHomeMenuAppletIdForDebug"},
{0x00130000, nullptr, "GetPreparationState"},
{0x00140040, nullptr, "SetPreparationState"},
{0x00150140, nullptr, "PrepareToStartApplication"},
{0x00160040, nullptr, "PreloadLibraryApplet"},
{0x00170040, nullptr, "FinishPreloadingLibraryApplet"},
{0x00180040, nullptr, "PrepareToStartLibraryApplet"},
{0x00190040, nullptr, "PrepareToStartSystemApplet"},
{0x001A0000, nullptr, "PrepareToStartNewestHomeMenu"},
{0x001B00C4, nullptr, "StartApplication"},
{0x001C0000, nullptr, "WakeupApplication"},
{0x001D0000, nullptr, "CancelApplication"},
{0x001E0084, nullptr, "StartLibraryApplet"},
{0x001F0084, nullptr, "StartSystemApplet"},
{0x00200044, nullptr, "StartNewestHomeMenu"},
{0x00210000, nullptr, "OrderToCloseApplication"},
{0x00220040, nullptr, "PrepareToCloseApplication"},
{0x00230040, nullptr, "PrepareToJumpToApplication"},
{0x00240044, nullptr, "JumpToApplication"},
{0x002500C0, nullptr, "PrepareToCloseLibraryApplet"},
{0x00260000, nullptr, "PrepareToCloseSystemApplet"},
{0x00270044, nullptr, "CloseApplication"},
{0x00280044, nullptr, "CloseLibraryApplet"},
{0x00290044, nullptr, "CloseSystemApplet"},
{0x002A0000, nullptr, "OrderToCloseSystemApplet"},
{0x002B0000, nullptr, "PrepareToJumpToHomeMenu"},
{0x002C0044, nullptr, "JumpToHomeMenu"},
{0x002D0000, nullptr, "PrepareToLeaveHomeMenu"},
{0x002E0044, nullptr, "LeaveHomeMenu"},
{0x002F0040, nullptr, "PrepareToLeaveResidentApplet"},
{0x00300044, nullptr, "LeaveResidentApplet"},
{0x00310100, nullptr, "PrepareToDoApplicationJump"},
{0x00320084, nullptr, "DoApplicationJump"},
{0x00330000, nullptr, "GetProgramIdOnApplicationJump"},
{0x00340084, nullptr, "SendDeliverArg"},
{0x00350080, nullptr, "ReceiveDeliverArg"},
{0x00360040, nullptr, "LoadSysMenuArg"},
{0x00370042, nullptr, "StoreSysMenuArg"},
{0x00380040, nullptr, "PreloadResidentApplet"},
{0x00390040, nullptr, "PrepareToStartResidentApplet"},
{0x003A0044, nullptr, "StartResidentApplet"},
{0x003B0040, nullptr, "CancelLibraryApplet"},
{0x003C0042, nullptr, "SendDspSleep"},
{0x003D0042, nullptr, "SendDspWakeUp"},
{0x003E0080, nullptr, "ReplySleepQuery"},
{0x003F0040, nullptr, "ReplySleepNotificationComplete"},
{0x00400042, nullptr, "SendCaptureBufferInfo"},
{0x00410040, nullptr, "ReceiveCaptureBufferInfo"},
{0x00420080, nullptr, "SleepSystem"},
{0x00430040, nullptr, "NotifyToWait"},
{0x00440000, nullptr, "GetSharedFont"},
{0x00450040, nullptr, "GetWirelessRebootInfo"},
{0x00460104, nullptr, "Wrap"},
{0x00470104, nullptr, "Unwrap"},
{0x00480100, nullptr, "GetProgramInfo"},
{0x00490180, nullptr, "Reboot"},
{0x004A0040, nullptr, "GetCaptureInfo"},
{0x004B00C2, nullptr, "AppletUtility"},
{0x004C0000, nullptr, "SetFatalErrDispMode"},
{0x004D0080, nullptr, "GetAppletProgramInfo"},
{0x004E0000, nullptr, "HardwareResetAsync"},
};
////////////////////////////////////////////////////////////////////////////////////////////////////

148
src/core/hle/service/fs.cpp Normal file
View file

@ -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

31
src/core/hle/service/fs.h Normal file
View file

@ -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

2
src/core/hle/service/service.cpp
View file

@ -10,6 +10,7 @@
#include "core/hle/service/service.h"
#include "core/hle/service/apt.h"
#include "core/hle/service/fs.h"
#include "core/hle/service/gsp.h"
#include "core/hle/service/hid.h"
#include "core/hle/service/ndm.h"
@ -71,6 +72,7 @@ void Init() {
g_manager->AddService(new SRV::Interface);
g_manager->AddService(new APT_U::Interface);
g_manager->AddService(new FS_User::Interface);
g_manager->AddService(new GSP_GPU::Interface);
g_manager->AddService(new HID_User::Interface);
g_manager->AddService(new NDM_U::Interface);

6
src/core/loader/elf.h
View file

@ -13,16 +13,16 @@
namespace Loader {
/// Loads an ELF/AXF file
class AppLoader_ELF : public AppLoader {
class AppLoader_ELF final : public AppLoader {
public:
AppLoader_ELF(const std::string& filename);
~AppLoader_ELF();
~AppLoader_ELF() override;
/**
* Load the bootable file
* @return ResultStatus result of function
*/
ResultStatus Load();
ResultStatus Load() override;
private:
std::string filename;

15
src/core/loader/loader.cpp
View file

@ -4,9 +4,11 @@
#include <memory>
#include "core/file_sys/archive_romfs.h"
#include "core/loader/loader.h"
#include "core/loader/elf.h"
#include "core/loader/ncch.h"
#include "core/hle/kernel/archive.h"
////////////////////////////////////////////////////////////////////////////////////////////////////
@ -51,14 +53,20 @@ ResultStatus LoadFile(const std::string& filename) {
switch (IdentifyFile(filename)) {
// Standard ELF file format...
case FileType::ELF: {
case FileType::ELF:
return AppLoader_ELF(filename).Load();
}
// NCCH/NCSD container formats...
case FileType::CXI:
case FileType::CCI: {
return AppLoader_NCCH(filename).Load();
AppLoader_NCCH app_loader(filename);
// Load application and RomFS
if (ResultStatus::Success == app_loader.Load()) {
Kernel::CreateArchive(new FileSys::Archive_RomFS(app_loader), "RomFS");
return ResultStatus::Success;
}
break;
}
// Error occurred durring IdentifyFile...
@ -70,7 +78,6 @@ ResultStatus LoadFile(const std::string& filename) {
default:
return ResultStatus::ErrorInvalidFormat;
}
return ResultStatus::Error;
}

55
src/core/loader/loader.h
View file

@ -32,6 +32,7 @@ enum class ResultStatus {
ErrorNotLoaded,
ErrorNotUsed,
ErrorAlreadyLoaded,
ErrorMemoryAllocationFailed,
};
/// Interface for loading an application
@ -48,60 +49,48 @@ public:
/**
* Get the code (typically .code section) of the application
* @param error ResultStatus result of function
* @return Reference to code buffer
* @param buffer Reference to buffer to store data
* @return ResultStatus result of function
*/
virtual const std::vector<u8>& ReadCode(ResultStatus& error) const {
error = ResultStatus::ErrorNotImplemented;
return code;
virtual ResultStatus ReadCode(std::vector<u8>& buffer) const {
return ResultStatus::ErrorNotImplemented;
}
/**
* Get the icon (typically icon section) of the application
* @param error ResultStatus result of function
* @return Reference to icon buffer
* @param buffer Reference to buffer to store data
* @return ResultStatus result of function
*/
virtual const std::vector<u8>& ReadIcon(ResultStatus& error) const {
error = ResultStatus::ErrorNotImplemented;
return icon;
virtual ResultStatus ReadIcon(std::vector<u8>& buffer) const {
return ResultStatus::ErrorNotImplemented;
}
/**
* Get the banner (typically banner section) of the application
* @param error ResultStatus result of function
* @return Reference to banner buffer
* @param buffer Reference to buffer to store data
* @return ResultStatus result of function
*/
virtual const std::vector<u8>& ReadBanner(ResultStatus& error) const {
error = ResultStatus::ErrorNotImplemented;
return banner;
virtual ResultStatus ReadBanner(std::vector<u8>& buffer) const {
return ResultStatus::ErrorNotImplemented;
}
/**
* Get the logo (typically logo section) of the application
* @param error ResultStatus result of function
* @return Reference to logo buffer
* @param buffer Reference to buffer to store data
* @return ResultStatus result of function
*/
virtual const std::vector<u8>& ReadLogo(ResultStatus& error) const {
error = ResultStatus::ErrorNotImplemented;
return logo;
virtual ResultStatus ReadLogo(std::vector<u8>& buffer) const {
return ResultStatus::ErrorNotImplemented;
}
/**
* Get the RomFs archive of the application
* @param error ResultStatus result of function
* @return Reference to RomFs archive buffer
* Get the RomFS of the application
* @param buffer Reference to buffer to store data
* @return ResultStatus result of function
*/
virtual const std::vector<u8>& ReadRomFS(ResultStatus& error) const {
error = ResultStatus::ErrorNotImplemented;
return romfs;
virtual ResultStatus ReadRomFS(std::vector<u8>& buffer) const {
return ResultStatus::ErrorNotImplemented;
}
protected:
std::vector<u8> code; ///< ExeFS .code section
std::vector<u8> icon; ///< ExeFS .icon section
std::vector<u8> banner; ///< ExeFS .banner section
std::vector<u8> logo; ///< ExeFS .logo section
std::vector<u8> romfs; ///< RomFs archive
};
/**

166
src/core/loader/ncch.cpp
View file

@ -113,76 +113,80 @@ AppLoader_NCCH::AppLoader_NCCH(const std::string& filename) {
/// AppLoader_NCCH destructor
AppLoader_NCCH::~AppLoader_NCCH() {
if (file.IsOpen())
file.Close();
}
/**
* Loads .code section into memory for booting
* @return ResultStatus result of function
*/
ResultStatus AppLoader_NCCH::LoadExec() {
ResultStatus AppLoader_NCCH::LoadExec() const {
if (!is_loaded)
return ResultStatus::ErrorNotLoaded;
ResultStatus res;
code = ReadCode(res);
if (ResultStatus::Success == res) {
std::vector<u8> code;
if (ResultStatus::Success == ReadCode(code)) {
Memory::WriteBlock(entry_point, &code[0], code.size());
Kernel::LoadExec(entry_point);
return ResultStatus::Success;
}
return res;
return ResultStatus::Error;
}
/**
* Reads an application ExeFS section of an NCCH file into AppLoader (e.g. .code, .logo, etc.)
* @param name Name of section to read out of NCCH file
* @param buffer Vector to read data into
* @param error ResultStatus result of function
* @return Reference to buffer of data that was read
* @return ResultStatus result of function
*/
const std::vector<u8>& AppLoader_NCCH::LoadSectionExeFS(const char* name, std::vector<u8>& buffer,
ResultStatus& error) {
ResultStatus AppLoader_NCCH::LoadSectionExeFS(const char* name, std::vector<u8>& buffer) const {
// Iterate through the ExeFs archive until we find the .code file...
for (int i = 0; i < kMaxSections; i++) {
// Load the specified section...
if (strcmp((const char*)exefs_header.section[i].name, name) == 0) {
INFO_LOG(LOADER, "ExeFS section %d:", i);
INFO_LOG(LOADER, " name: %s", exefs_header.section[i].name);
INFO_LOG(LOADER, " offset: 0x%08X", exefs_header.section[i].offset);
INFO_LOG(LOADER, " size: 0x%08X", exefs_header.section[i].size);
File::IOFile file(filename, "rb");
if (file.IsOpen()) {
for (int i = 0; i < kMaxSections; i++) {
// Load the specified section...
if (strcmp((const char*)exefs_header.section[i].name, name) == 0) {
INFO_LOG(LOADER, "ExeFS section %d:", i);
INFO_LOG(LOADER, " name: %s", exefs_header.section[i].name);
INFO_LOG(LOADER, " offset: 0x%08X", exefs_header.section[i].offset);
INFO_LOG(LOADER, " size: 0x%08X", exefs_header.section[i].size);
s64 section_offset = (exefs_header.section[i].offset + exefs_offset +
sizeof(ExeFs_Header) + ncch_offset);
file.Seek(section_offset, 0);
s64 section_offset = (exefs_header.section[i].offset + exefs_offset +
sizeof(ExeFs_Header)+ncch_offset);
file.Seek(section_offset, 0);
// Section is compressed...
if (i == 0 && is_compressed) {
// Read compressed .code section...
std::unique_ptr<u8[]> temp_buffer(new u8[exefs_header.section[i].size]);
file.ReadBytes(&temp_buffer[0], exefs_header.section[i].size);
// Section is compressed...
if (i == 0 && is_compressed) {
// Read compressed .code section...
std::unique_ptr<u8[]> temp_buffer;
try {
temp_buffer.reset(new u8[exefs_header.section[i].size]);
} catch (std::bad_alloc&) {
return ResultStatus::ErrorMemoryAllocationFailed;
}
file.ReadBytes(&temp_buffer[0], exefs_header.section[i].size);
// Decompress .code section...
u32 decompressed_size = LZSS_GetDecompressedSize(&temp_buffer[0],
exefs_header.section[i].size);
buffer.resize(decompressed_size);
if (!LZSS_Decompress(&temp_buffer[0], exefs_header.section[i].size, &buffer[0],
decompressed_size)) {
error = ResultStatus::ErrorInvalidFormat;
return buffer;
// Decompress .code section...
u32 decompressed_size = LZSS_GetDecompressedSize(&temp_buffer[0],
exefs_header.section[i].size);
buffer.resize(decompressed_size);
if (!LZSS_Decompress(&temp_buffer[0], exefs_header.section[i].size, &buffer[0],
decompressed_size)) {
return ResultStatus::ErrorInvalidFormat;
}
// Section is uncompressed...
}
// Section is uncompressed...
} else {
buffer.resize(exefs_header.section[i].size);
file.ReadBytes(&buffer[0], exefs_header.section[i].size);
else {
buffer.resize(exefs_header.section[i].size);
file.ReadBytes(&buffer[0], exefs_header.section[i].size);
}
return ResultStatus::Success;
}
error = ResultStatus::Success;
return buffer;
}
} else {
ERROR_LOG(LOADER, "Unable to read file %s!", filename.c_str());
return ResultStatus::Error;
}
error = ResultStatus::ErrorNotUsed;
return buffer;
return ResultStatus::ErrorNotUsed;
}
/**
@ -197,8 +201,7 @@ ResultStatus AppLoader_NCCH::Load() {
if (is_loaded)
return ResultStatus::ErrorAlreadyLoaded;
file = File::IOFile(filename, "rb");
File::IOFile file(filename, "rb");
if (file.IsOpen()) {
file.ReadBytes(&ncch_header, sizeof(NCCH_Header));
@ -241,72 +244,77 @@ ResultStatus AppLoader_NCCH::Load() {
LoadExec(); // Load the executable into memory for booting
return ResultStatus::Success;
} else {
ERROR_LOG(LOADER, "Unable to read file %s!", filename.c_str());
}
return ResultStatus::Error;
}
/**
* Get the code (typically .code section) of the application
* @param error ResultStatus result of function
* @return Reference to code buffer
* @param buffer Reference to buffer to store data
* @return ResultStatus result of function
*/
const std::vector<u8>& AppLoader_NCCH::ReadCode(ResultStatus& error) {
return LoadSectionExeFS(".code", code, error);
ResultStatus AppLoader_NCCH::ReadCode(std::vector<u8>& buffer) const {
return LoadSectionExeFS(".code", buffer);
}
/**
* Get the icon (typically icon section) of the application
* @param error ResultStatus result of function
* @return Reference to icon buffer
* @param buffer Reference to buffer to store data
* @return ResultStatus result of function
*/
const std::vector<u8>& AppLoader_NCCH::ReadIcon(ResultStatus& error) {
return LoadSectionExeFS("icon", icon, error);
ResultStatus AppLoader_NCCH::ReadIcon(std::vector<u8>& buffer) const {
return LoadSectionExeFS("icon", buffer);
}
/**
* Get the banner (typically banner section) of the application
* @param error ResultStatus result of function
* @return Reference to banner buffer
* @param buffer Reference to buffer to store data
* @return ResultStatus result of function
*/
const std::vector<u8>& AppLoader_NCCH::ReadBanner(ResultStatus& error) {
return LoadSectionExeFS("banner", banner, error);
ResultStatus AppLoader_NCCH::ReadBanner(std::vector<u8>& buffer) const {
return LoadSectionExeFS("banner", buffer);
}
/**
* Get the logo (typically logo section) of the application
* @param error ResultStatus result of function
* @return Reference to logo buffer
* @param buffer Reference to buffer to store data
* @return ResultStatus result of function
*/
const std::vector<u8>& AppLoader_NCCH::ReadLogo(ResultStatus& error) {
return LoadSectionExeFS("logo", logo, error);
ResultStatus AppLoader_NCCH::ReadLogo(std::vector<u8>& buffer) const {
return LoadSectionExeFS("logo", buffer);
}
/**
* Get the RomFs archive of the application
* @param error ResultStatus result of function
* @return Reference to RomFs archive buffer
* Get the RomFS of the application
* @param buffer Reference to buffer to store data
* @return ResultStatus result of function
*/
const std::vector<u8>& AppLoader_NCCH::ReadRomFS(ResultStatus& error) {
// Check if the NCCH has a RomFS...
if (ncch_header.romfs_offset != 0 && ncch_header.romfs_size != 0) {
u32 romfs_offset = ncch_offset + (ncch_header.romfs_offset * kBlockSize) + 0x1000;
u32 romfs_size = (ncch_header.romfs_size * kBlockSize) - 0x1000;
ResultStatus AppLoader_NCCH::ReadRomFS(std::vector<u8>& buffer) const {
File::IOFile file(filename, "rb");
if (file.IsOpen()) {
// Check if the NCCH has a RomFS...
if (ncch_header.romfs_offset != 0 && ncch_header.romfs_size != 0) {
u32 romfs_offset = ncch_offset + (ncch_header.romfs_offset * kBlockSize) + 0x1000;
u32 romfs_size = (ncch_header.romfs_size * kBlockSize) - 0x1000;
INFO_LOG(LOADER, "RomFS offset: 0x%08X", romfs_offset);
INFO_LOG(LOADER, "RomFS size: 0x%08X", romfs_size);
INFO_LOG(LOADER, "RomFS offset: 0x%08X", romfs_offset);
INFO_LOG(LOADER, "RomFS size: 0x%08X", romfs_size);
romfs.resize(romfs_size);
buffer.resize(romfs_size);
file.Seek(romfs_offset, 0);
file.ReadBytes(&romfs[0], romfs_size);
file.Seek(romfs_offset, 0);
file.ReadBytes(&buffer[0], romfs_size);
error = ResultStatus::Success;
return romfs;
} else {
return ResultStatus::Success;
}
NOTICE_LOG(LOADER, "RomFS unused");
return ResultStatus::ErrorNotUsed;
} else {
ERROR_LOG(LOADER, "Unable to read file %s!", filename.c_str());
}
error = ResultStatus::ErrorNotUsed;
return romfs;
return ResultStatus::Error;
}
} // namespace Loader

47
src/core/loader/ncch.h
View file

@ -145,51 +145,51 @@ struct ExHeader_Header{
namespace Loader {
/// Loads an NCCH file (e.g. from a CCI, or the first NCCH in a CXI)
class AppLoader_NCCH : public AppLoader {
class AppLoader_NCCH final : public AppLoader {
public:
AppLoader_NCCH(const std::string& filename);
~AppLoader_NCCH();
~AppLoader_NCCH() override;
/**
* Load the application
* @return ResultStatus result of function
*/
ResultStatus Load();
ResultStatus Load() override;
/**
* Get the code (typically .code section) of the application
* @param error ResultStatus result of function
* @return Reference to code buffer
* @param buffer Reference to buffer to store data
* @return ResultStatus result of function
*/
const std::vector<u8>& ReadCode(ResultStatus& error);
ResultStatus ReadCode(std::vector<u8>& buffer) const override;
/**
* Get the icon (typically icon section) of the application
* @param error ResultStatus result of function
* @return Reference to icon buffer
* @param buffer Reference to buffer to store data
* @return ResultStatus result of function
*/
const std::vector<u8>& ReadIcon(ResultStatus& error);
ResultStatus ReadIcon(std::vector<u8>& buffer) const override;
/**
* Get the banner (typically banner section) of the application
* @param error ResultStatus result of function
* @return Reference to banner buffer
* @param buffer Reference to buffer to store data
* @return ResultStatus result of function
*/
const std::vector<u8>& ReadBanner(ResultStatus& error);
ResultStatus ReadBanner(std::vector<u8>& buffer) const override;
/**
* Get the logo (typically logo section) of the application
* @param error ResultStatus result of function
* @return Reference to logo buffer
* @param buffer Reference to buffer to store data
* @return ResultStatus result of function
*/
const std::vector<u8>& ReadLogo(ResultStatus& error);
ResultStatus ReadLogo(std::vector<u8>& buffer) const override;
/**
* Get the RomFs archive of the application
* @param error ResultStatus result of function
* @return Reference to RomFs archive buffer
* Get the RomFS of the application
* @param buffer Reference to buffer to store data
* @return ResultStatus result of function
*/
const std::vector<u8>& ReadRomFS(ResultStatus& error);
ResultStatus ReadRomFS(std::vector<u8>& buffer) const override;
private:
@ -197,19 +197,16 @@ private:
* Reads an application ExeFS section of an NCCH file into AppLoader (e.g. .code, .logo, etc.)
* @param name Name of section to read out of NCCH file
* @param buffer Vector to read data into
* @param error ResultStatus result of function
* @return Reference to buffer of data that was read
* @return ResultStatus result of function
*/
const std::vector<u8>& LoadSectionExeFS(const char* name, std::vector<u8>& buffer,
ResultStatus& error);
ResultStatus LoadSectionExeFS(const char* name, std::vector<u8>& buffer) const;
/**
* Loads .code section into memory for booting
* @return ResultStatus result of function
*/
ResultStatus LoadExec();
ResultStatus LoadExec() const;
File::IOFile file;
std::string filename;
bool is_loaded;

2
src/core/system.cpp
View file

@ -15,7 +15,6 @@
namespace System {
volatile State g_state;
MetaFileSystem g_ctr_file_system;
void UpdateState(State state) {
}
@ -45,7 +44,6 @@ void Shutdown() {
CoreTiming::Shutdown();
VideoCore::Shutdown();
Kernel::Shutdown();
g_ctr_file_system.Shutdown();
}
} // namespace

2
src/core/system.h
View file

@ -5,7 +5,6 @@
#pragma once
#include "common/emu_window.h"
#include "core/file_sys/meta_file_system.h"
////////////////////////////////////////////////////////////////////////////////////////////////////
@ -24,7 +23,6 @@ typedef enum {
} State;
extern volatile State g_state;
extern MetaFileSystem g_ctr_file_system;
void UpdateState(State state);
void Init(EmuWindow* emu_window);