Play your Steam library's Windows games on a jailbroken PS5.
C++
#include "steam/backend/cloud_mapping.h"
#include <algorithm>
#include <cctype>
#include <set>
namespace playden::steam::cloud {
namespace {
std::string Lower(std::string_view text) {
std::string result(text);
for (auto& value : result) value = static_cast<char>(std::tolower(static_cast<unsigned char>(value)));
return result;
}
std::string Join(const std::string& left, const std::string& right) {
if (left.empty()) return right;
if (right.empty()) return left;
return left + "/" + right;
}
std::string Replace(std::string text, const std::string& find, const std::string& replace) {
for (std::size_t at = text.find(find); at != std::string::npos; at = text.find(find, at + replace.size()))
text.replace(at, find.size(), replace);
return text;
}
// Path segments must be plain names: no empty, "." or ".." parts and no characters that would
// leave a placeholder unresolved or point outside the root.
bool SafeComponents(std::string_view path) {
if (path.empty()) return true;
if (path.front() == '/') return false;
for (const char value : path)
if (value == '%' || value == '{' || value == '}' || value == '*' || value == '?' || value == '<' ||
value == '>' || value == '|' || value == '\r' || value == '\n' || value == '\0' || value == ':' || value == '\\')
return false;
std::size_t start = 0;
while (start <= path.size()) {
const auto end = std::min(path.find('/', start), path.size());
const auto part = path.substr(start, end - start);
if (part.empty() || part == "." || part == "..") return false;
start = end + 1;
}
return true;
}
// A declared path: backslashes become slashes, trailing separators go. One leading separator is how many games write a
// path below their root ("/My Games/Fallout4/Saves" under WinMyDocuments, as Steam's Cloud names write "%Root%/folder"),
// so it goes too; a second one (a UNC "\\server" form), a drive letter or ".." is still refused.
std::optional<std::string> RelativePath(std::string path, std::uint64_t steam_id, bool* needs_account) {
std::replace(path.begin(), path.end(), '\\', '/');
if (!path.empty() && path.front() == '/') path.erase(path.begin());
if (!path.empty() && path.front() == '/') return std::nullopt;
while (!path.empty() && path.back() == '/') path.pop_back();
if (path.find("{64BitSteamID}") != std::string::npos || path.find("{Steam3AccountID}") != std::string::npos) {
if (steam_id == 0) {
*needs_account = true;
return std::nullopt;
}
path = Replace(path, "{64BitSteamID}", std::to_string(steam_id));
path = Replace(path, "{Steam3AccountID}", std::to_string(steam_id & 0xffffffffULL));
}
if (!SafeComponents(path)) return std::nullopt;
return path;
}
bool ValidPattern(std::string_view pattern) {
if (pattern.empty() || pattern == "." || pattern == "..") return false;
for (const char value : pattern)
if (value == '/' || value == '\\' || value == '\0' || value == ':' || value == '[' || value == ']' || value == '{' ||
value == '}' || value == '\r' || value == '\n')
return false;
return true;
}
// Where each Windows root lives in a prospero-win style prefix.
std::optional<std::pair<SaveRoot, std::string>> Base(SavePathRoot root) {
const std::string user = kPrefixUserFolder;
switch (root) {
case SavePathRoot::kGameInstall: return std::make_pair(SaveRoot::kGame, std::string());
case SavePathRoot::kWinMyDocuments: return std::make_pair(SaveRoot::kPrefix, user + "/Documents");
case SavePathRoot::kWinAppDataLocal: return std::make_pair(SaveRoot::kPrefix, user + "/AppData/Local");
case SavePathRoot::kWinAppDataLocalLow: return std::make_pair(SaveRoot::kPrefix, user + "/AppData/LocalLow");
case SavePathRoot::kWinAppDataRoaming: return std::make_pair(SaveRoot::kPrefix, user + "/AppData/Roaming");
case SavePathRoot::kWinSavedGames: return std::make_pair(SaveRoot::kPrefix, user + "/Saved Games");
case SavePathRoot::kWinProgramData: return std::make_pair(SaveRoot::kPrefix, std::string("drive_c/ProgramData"));
case SavePathRoot::kRoot: return std::make_pair(SaveRoot::kPrefix, user);
default: return std::nullopt;
}
}
// Steam writes both "%Root%/folder" and "%Root%folder"; normalize only that separator and the
// root aliases. Bare user-data names lose their token.
std::optional<std::string> Normalized(const std::string& raw) {
std::string name = raw;
std::replace(name.begin(), name.end(), '\\', '/');
if (!name.empty() && name.front() == '%') {
const auto end = name.find('%', 1);
if (end == std::string::npos || end == 1) return std::nullopt;
const auto token = name.substr(1, end - 1);
for (const char value : token)
if (!(std::isalnum(static_cast<unsigned char>(value)) || value == '_')) return std::nullopt;
std::string remainder = name.substr(end + 1);
if (!remainder.empty() && remainder.front() == '/') remainder.erase(remainder.begin());
if (!SafeComponents(remainder)) return std::nullopt;
const auto lower = Lower(token);
std::string root = "%" + token + "%";
if (lower == "steamuserdata" || lower == "steamuserbasestorage") return remainder;
if (lower == "steamclouddocuments") root = "%WinMyDocuments%";
if (lower == "windowshome" || lower == "root_mod") root = "%Root%";
return root + (remainder.empty() ? "" : "/" + remainder);
}
if (!SafeComponents(name)) return std::nullopt;
return name;
}
std::optional<std::string> Suffix(const std::string& name, const std::string& prefix) {
if (prefix.empty()) return name.empty() ? std::nullopt : std::optional<std::string>(name);
const std::string start = prefix.back() == '/' ? prefix : prefix + "/";
if (name.size() <= start.size() || Lower(name.substr(0, start.size())) != Lower(start)) return std::nullopt;
return name.substr(start.size());
}
bool Matches(const std::string& suffix, const SaveRule& rule) {
if (suffix.empty() || (!rule.recursive && suffix.find('/') != std::string::npos)) return false;
const auto slash = suffix.rfind('/');
return GlobMatch(rule.pattern, slash == std::string::npos ? suffix : suffix.substr(slash + 1));
}
bool SameRule(const SaveRule& left, const SaveRule& right) {
return left.root == right.root && left.directory == right.directory && left.pattern == right.pattern &&
left.recursive == right.recursive && left.cloud_prefix == right.cloud_prefix;
}
// A macOS or Linux save location listed beside the Windows ones without "platforms" (Cat Quest lists one per OS):
// its root is still the other OS's, or a Windows override sends it to the folder of a Windows entry, whose saves the
// Windows client keeps under that entry's Cloud names. The Mac or Linux client syncs its files; the sync leaves them
// alone (they match no rule), so progress kept only under the Mac names stays in the Cloud, not on the console. One a
// Windows override sends to a folder of its own stays unresolved. Paths and patterns match without case, as files do.
bool OtherPlatformCopy(const CloudSaveInfo& info, const SaveFilePattern& item) {
if (item.upload_root == SavePathRoot::kNone || IsWindowsSavePathRoot(item.upload_root)) return false;
if (!IsWindowsSavePathRoot(item.root)) return true;
const auto folder = [](const std::string& path) {
auto lower = Lower(path);
if (!lower.empty() && lower.front() == '/') lower.erase(lower.begin());
while (!lower.empty() && lower.back() == '/') lower.pop_back();
return lower;
};
return std::any_of(info.patterns.begin(), info.patterns.end(), [&](const SaveFilePattern& other) {
return IsWindowsSavePathRoot(other.upload_root) && other.root == item.root && folder(other.path) == folder(item.path) &&
Lower(other.pattern) == Lower(item.pattern) && other.recursive == item.recursive;
});
}
} // namespace
std::string LocalSavePath::key() const { return (root == SaveRoot::kGame ? "game/" : "prefix/") + Lower(path); }
bool GlobMatch(std::string_view pattern, std::string_view text) {
// Iterative wildcard matching with single-star backtracking.
std::size_t p = 0, t = 0, star = std::string_view::npos, mark = 0;
const auto same = [](char a, char b) {
return std::tolower(static_cast<unsigned char>(a)) == std::tolower(static_cast<unsigned char>(b));
};
while (t < text.size()) {
if (p < pattern.size() && (pattern[p] == '?' || same(pattern[p], text[t]))) { ++p; ++t; }
else if (p < pattern.size() && pattern[p] == '*') { star = p++; mark = t; }
else if (star != std::string_view::npos) { p = star + 1; t = ++mark; }
else return false;
}
while (p < pattern.size() && pattern[p] == '*') ++p;
return p == pattern.size();
}
SaveMapping BuildSaveMapping(const CloudSaveInfo& info, std::uint32_t app_id, std::uint64_t steam_id) {
SaveMapping mapping;
if (!info.declared) {
mapping.unresolved.push_back("This game does not use Steam Cloud.");
return mapping;
}
// The Steam emulator keeps ISteamRemoteStorage files under <appid>/remote: bare Cloud names land there.
const std::string remote = std::string(kEmulatorUserData) + "/" + std::to_string(app_id) + "/remote";
if (info.quota > 0 || info.max_num_files > 0 || !info.patterns.empty())
mapping.rules.push_back({SaveRoot::kPrefix, remote, "*", true, ""});
for (const auto& item : info.patterns) {
bool needs_account = false;
const auto path = RelativePath(item.path, steam_id, &needs_account);
const auto upload_path = RelativePath(item.upload_path, steam_id, &needs_account);
const auto base = item.root == SavePathRoot::kSteamUserData ? std::make_optional(std::make_pair(SaveRoot::kPrefix, remote))
: Base(item.root);
if (OtherPlatformCopy(info, item)) continue;
if (needs_account) {
mapping.unresolved.push_back("Sign in to resolve this game's account save folder.");
continue;
}
if (!base || !path || !upload_path || !IsWindowsSavePathRoot(item.upload_root) || !ValidPattern(item.pattern) ||
(item.recursive != 0 && item.recursive != 1)) {
mapping.unresolved.push_back("A save location is not supported yet.");
continue;
}
SaveRule rule;
rule.root = base->first;
rule.directory = Join(base->second, *path);
rule.pattern = item.pattern;
rule.recursive = item.recursive == 1;
rule.cloud_prefix = item.upload_root == SavePathRoot::kSteamUserData
? *upload_path
: "%" + std::string(SavePathRootName(item.upload_root)) + "%" + *upload_path;
if (std::none_of(mapping.rules.begin(), mapping.rules.end(), [&](const SaveRule& other) { return SameRule(other, rule); }))
mapping.rules.push_back(std::move(rule));
}
std::sort(mapping.unresolved.begin(), mapping.unresolved.end());
mapping.unresolved.erase(std::unique(mapping.unresolved.begin(), mapping.unresolved.end()), mapping.unresolved.end());
return mapping;
}
SavePaths::SavePaths(SaveMapping mapping) {
for (auto& rule : mapping.rules)
if (SafeComponents(rule.directory) && ValidPattern(rule.pattern) && Normalized(rule.cloud_prefix))
rules_.push_back(std::move(rule));
}
std::optional<LocalSavePath> SavePaths::LocalFor(const std::string& remote_name, std::string* error) const {
const auto fail = [&](const char* why) -> std::optional<LocalSavePath> {
if (error) *error = why;
return std::nullopt;
};
const auto name = Normalized(remote_name);
if (!name) return fail("A Cloud save name is not supported.");
// The most specific (longest) matching prefix wins; equally specific rules must agree.
std::vector<std::pair<std::size_t, LocalSavePath>> matches;
for (const auto& rule : rules_) {
const auto prefix = Normalized(rule.cloud_prefix).value_or("");
// The bare-name fallback must never swallow an unknown %Root% name.
if (prefix.empty() && !name->empty() && name->front() == '%') continue;
const auto suffix = Suffix(*name, prefix);
if (!suffix || !Matches(*suffix, rule)) continue;
const auto local = Join(rule.directory, *suffix);
if (SafeComponents(local)) matches.push_back({prefix.size(), {rule.root, local}});
}
if (matches.empty()) return std::nullopt;
std::size_t longest = 0;
for (const auto& match : matches) longest = std::max(longest, match.first);
std::set<std::string> keys;
const LocalSavePath* chosen = nullptr;
for (const auto& match : matches) {
if (match.first != longest) continue;
keys.insert(match.second.key());
chosen = &match.second;
}
if (keys.size() != 1) return fail("A Cloud save matches more than one local folder.");
return *chosen;
}
std::optional<std::string> SavePaths::RemoteFor(const LocalSavePath& local) const {
if (!SafeComponents(local.path)) return std::nullopt;
std::set<std::string> names;
std::string chosen;
for (const auto& rule : rules_) {
if (rule.root != local.root) continue;
const auto suffix = Suffix(local.path, rule.directory);
if (!suffix || !Matches(*suffix, rule)) continue;
std::string prefix = rule.cloud_prefix;
std::replace(prefix.begin(), prefix.end(), '\\', '/');
const std::string name = prefix + (prefix.empty() || prefix.back() == '/' || prefix.back() == '%' ? "" : "/") + *suffix;
const auto back = LocalFor(name);
if (back && back->key() == local.key()) {
names.insert(Lower(name));
chosen = name;
}
}
if (names.size() != 1) return std::nullopt;
return chosen;
}
} // namespace playden::steam::cloud