archive/rpcs3
1
0
Fork 0
mirror of https://github.com/RPCS3/rpcs3.git synced 2025-07-06 23:11:25 +12:00
Code Issues Projects Releases Packages Wiki Activity Actions

Loader/cellGame: Do not crash on invalid PSF files

Browse source
This commit is contained in:
Eladash 2021-03-31 00:44:58 +03:00 • committed by Ivan
parent 10bbb7fa1f
commit a8d5a8734a
5 changed files with 88 additions and 40 deletions
Download patch file Download diff file Expand all files Collapse all files

16
rpcs3/Emu/Cell/Modules/cellGame.cpp
View file

@ -182,9 +182,9 @@ error_code cellHddGameCheck(ppu_thread& ppu, u32 version, vm::cptr<char> dirName
const std::string dir = "/dev_hdd0/game/" + game_dir;
psf::registry sfo = psf::load_object(fs::file(vfs::get(dir + "/PARAM.SFO")));
auto [sfo, psf_error] = psf::load(vfs::get(dir + "/PARAM.SFO"));
const u32 new_data = sfo.empty() && !fs::is_file(vfs::get(dir + "/PARAM.SFO")) ? CELL_GAMEDATA_ISNEWDATA_YES : CELL_GAMEDATA_ISNEWDATA_NO;
const u32 new_data = psf_error == psf::error::stream ? CELL_GAMEDATA_ISNEWDATA_YES : CELL_GAMEDATA_ISNEWDATA_NO;
if (!new_data)
{
@ -586,7 +586,7 @@ error_code cellGameDataCheck(u32 type, vm::cptr<char> dirName, vm::ptr<CellGameC
return CELL_GAME_ERROR_BUSY;
}
auto sfo = psf::load_object(fs::file(vfs::get(dir + "/PARAM.SFO")));
auto [sfo, psf_error] = psf::load(vfs::get(dir + "/PARAM.SFO"));
if (psf::get_string(sfo, "CATEGORY") != [&]()
{
@ -599,7 +599,7 @@ error_code cellGameDataCheck(u32 type, vm::cptr<char> dirName, vm::ptr<CellGameC
}
}())
{
if (fs::is_file(vfs::get(dir + "/PARAM.SFO")))
if (psf_error != psf::error::stream)
{
init.cancel();
return CELL_GAME_ERROR_BROKEN;
@ -714,9 +714,9 @@ error_code cellGameDataCheckCreate2(ppu_thread& ppu, u32 version, vm::cptr<char>
const std::string game_dir = dirName.get_ptr();
const std::string dir = "/dev_hdd0/game/"s + game_dir;
psf::registry sfo = psf::load_object(fs::file(vfs::get(dir + "/PARAM.SFO")));
auto [sfo, psf_error] = psf::load(vfs::get(dir + "/PARAM.SFO"));
const u32 new_data = sfo.empty() && !fs::is_file(vfs::get(dir + "/PARAM.SFO")) ? CELL_GAMEDATA_ISNEWDATA_YES : CELL_GAMEDATA_ISNEWDATA_NO;
const u32 new_data = psf_error == psf::error::stream ? CELL_GAMEDATA_ISNEWDATA_YES : CELL_GAMEDATA_ISNEWDATA_NO;
if (!new_data)
{
@ -961,9 +961,9 @@ error_code cellGameDeleteGameData(vm::cptr<char> dirName)
return CELL_GAME_ERROR_NOTSUPPORTED;
}
psf::registry sfo = psf::load_object(fs::file(dir + "/PARAM.SFO"));
const auto [sfo, psf_error] = psf::load(dir + "/PARAM.SFO");
if (psf::get_string(sfo, "CATEGORY") != "GD" && fs::is_file(dir + "/PARAM.SFO"))
if (psf::get_string(sfo, "CATEGORY") != "GD" && psf_error != psf::error::stream)
{
return CELL_GAME_ERROR_NOTSUPPORTED;
}

72
rpcs3/Loader/PSF.cpp
View file

@ -21,6 +21,23 @@ void fmt_class_string<psf::format>::format(std::string& out, u64 arg)
});
}
template<>
void fmt_class_string<psf::error>::format(std::string& out, u64 arg)
{
format_enum(out, arg, [](auto fmt)
{
switch (fmt)
{
case psf::error::stream: return "File doesn't exist";
case psf::error::not_psf: return "File is not of PSF format";
case psf::error::corrupt: return "PSF is truncated or corrupted";
default: break;
}
return unknown;
});
}
namespace psf
{
struct header_t
@ -103,51 +120,52 @@ namespace psf
fmt::throw_exception("Invalid format (0x%x)", m_type);
}
registry load_object(const fs::file& stream)
load_result_t load(const fs::file& stream)
{
registry result;
#define PSF_CHECK(cond, err) if (!static_cast<bool>(cond)) { if (error::err != error::stream) psf_log.error("Error loading PSF: %s%s", (errc = error::err), \
src_loc{__builtin_LINE(), __builtin_COLUMN(), __builtin_FILE(), __builtin_FUNCTION()}); \
return result.clear(), pair; }
// Hack for empty input (TODO)
if (!stream || !stream.size())
{
return result;
}
load_result_t pair{};
auto& [result, errc] = pair;
PSF_CHECK(stream, stream);
stream.seek(0);
// Get header
header_t header;
ensure(stream.read(header));
PSF_CHECK(stream.read(header), not_psf);
// Check magic and version
ensure(header.magic == "\0PSF"_u32);
ensure(header.version == 0x101u);
ensure(sizeof(header_t) + header.entries_num * sizeof(def_table_t) <= header.off_key_table);
ensure(header.off_key_table <= header.off_data_table);
ensure(header.off_data_table <= stream.size());
PSF_CHECK(header.magic == "\0PSF"_u32, not_psf);
PSF_CHECK(header.version == 0x101u, not_psf);
PSF_CHECK(header.off_key_table >= sizeof(header_t), corrupt);
PSF_CHECK(header.off_key_table <= header.off_data_table, corrupt);
PSF_CHECK(header.off_data_table <= stream.size(), corrupt);
// Get indices
std::vector<def_table_t> indices;
ensure(stream.read(indices, header.entries_num));
PSF_CHECK(stream.read<true>(indices, header.entries_num), corrupt);
// Get keys
std::string keys;
ensure(stream.seek(header.off_key_table) == header.off_key_table);
ensure(stream.read(keys, header.off_data_table - header.off_key_table));
PSF_CHECK(stream.seek(header.off_key_table) == header.off_key_table, corrupt);
PSF_CHECK(stream.read<true>(keys, header.off_data_table - header.off_key_table), corrupt);
// Load entries
for (u32 i = 0; i < header.entries_num; ++i)
{
ensure(indices[i].key_off < header.off_data_table - header.off_key_table);
PSF_CHECK(indices[i].key_off < header.off_data_table - header.off_key_table, corrupt);
// Get key name (null-terminated string)
std::string key(keys.data() + indices[i].key_off);
// Check entry
ensure(result.count(key) == 0);
ensure(indices[i].param_len <= indices[i].param_max);
ensure(indices[i].data_off < stream.size() - header.off_data_table);
ensure(indices[i].param_max < stream.size() - indices[i].data_off);
PSF_CHECK(result.count(key) == 0, corrupt);
PSF_CHECK(indices[i].param_len <= indices[i].param_max, corrupt);
PSF_CHECK(indices[i].data_off < stream.size() - header.off_data_table, corrupt);
PSF_CHECK(indices[i].param_max < stream.size() - indices[i].data_off, corrupt);
// Seek data pointer
stream.seek(header.off_data_table + indices[i].data_off);
@ -156,7 +174,7 @@ namespace psf
{
// Integer data
le_t<u32> value;
ensure(stream.read(value));
PSF_CHECK(stream.read(value), corrupt);
result.emplace(std::piecewise_construct,
std::forward_as_tuple(std::move(key)),
@ -166,7 +184,7 @@ namespace psf
{
// String/array data
std::string value;
ensure(stream.read(value, indices[i].param_len));
PSF_CHECK(stream.read<true>(value, indices[i].param_len), corrupt);
if (indices[i].param_fmt == format::string)
{
@ -185,7 +203,13 @@ namespace psf
}
}
return result;
#undef PSF_CHECK
return pair;
}
load_result_t load(const std::string& filename)
{
return load(fs::file(filename));
}
std::vector<u8> save_object(const psf::registry& psf, std::vector<u8>&& init)

23
rpcs3/Loader/PSF.h
View file

@ -19,6 +19,14 @@ namespace psf
integer = 0x0404,
};
enum class error
{
ok,
stream,
not_psf,
corrupt,
};
class entry final
{
format m_type{};
@ -49,8 +57,21 @@ namespace psf
// Define PSF registry as a sorted map of entries:
using registry = std::map<std::string, entry>;
struct load_result_t
{
registry sfo;
error errc;
explicit operator bool() const
{
return !sfo.empty();
}
};
// Load PSF registry from SFO binary format
registry load_object(const fs::file&);
load_result_t load(const fs::file&);
load_result_t load(const std::string& filename);
inline registry load_object(const fs::file& f) { return load(f).sfo; }
// Convert PSF registry to SFO binary format
std::vector<u8> save_object(const registry&, std::vector<u8>&& init = std::vector<u8>{});

13
rpcs3/rpcs3qt/game_list_frame.cpp
View file

@ -550,17 +550,20 @@ void game_list_frame::Refresh(const bool from_drive, const bool scroll_after)
{
const std::string sfo_dir = Emulator::GetSfoDirFromGamePath(dir, Emu.GetUsr());
const fs::file sfo_file(sfo_dir + "/PARAM.SFO");
if (!sfo_file)
const psf::registry psf = psf::load_object(fs::file(sfo_dir + "/PARAM.SFO"));
const std::string_view title_id = psf::get_string(psf, "TITLE_ID", "");
if (title_id.empty())
{
// Do not care about invalid entries
return;
}
const auto psf = psf::load_object(sfo_file);
GameInfo game;
game.path = dir;
game.serial = std::string(psf::get_string(psf, "TITLE_ID", ""));
game.serial = std::string(title_id);
game.name = std::string(psf::get_string(psf, "TITLE", cat_unknown_localized));
game.app_ver = std::string(psf::get_string(psf, "APP_VER", cat_unknown_localized));
game.version = std::string(psf::get_string(psf, "VERSION", cat_unknown_localized));

4
rpcs3/rpcs3qt/save_manager_dialog.cpp
View file

@ -55,11 +55,11 @@ namespace
}
// PSF parameters
const auto& psf = psf::load_object(fs::file(base_dir + entry.name + "/PARAM.SFO"));
const auto [psf, errc] = psf::load(base_dir + entry.name + "/PARAM.SFO");
if (psf.empty())
{
gui_log.error("Failed to load savedata: %s", base_dir + "/" + entry.name);
gui_log.error("Failed to load savedata: %s (%s)", base_dir + "/" + entry.name, errc);
continue;
}