1
0
mirror of synced 2024-12-15 17:21:16 +01:00
ImHex/lib/libimhex/source/helpers/fs.cpp

333 lines
12 KiB
C++
Raw Normal View History

2022-03-04 11:44:11 +01:00
#include <hex/helpers/fs.hpp>
#include <hex/api/content_registry.hpp>
#include <hex/helpers/fs_macos.hpp>
#include <hex/helpers/file.hpp>
#include <hex/helpers/intrinsics.hpp>
#include <hex/helpers/net.hpp>
2021-12-03 00:00:25 +01:00
#include <xdg.hpp>
#if defined(OS_WINDOWS)
#include <windows.h>
#include <shlobj.h>
#elif defined(OS_LINUX)
#include <xdg.hpp>
#include <linux/limits.h>
#endif
#include <algorithm>
#include <filesystem>
namespace hex::fs {
std::optional<std::fs::path> getExecutablePath() {
#if defined(OS_WINDOWS)
std::wstring exePath(MAX_PATH, '\0');
if (GetModuleFileNameW(nullptr, exePath.data(), exePath.length()) == 0)
return std::nullopt;
return exePath;
#elif defined(OS_LINUX)
std::string exePath(PATH_MAX, '\0');
if (readlink("/proc/self/exe", exePath.data(), PATH_MAX) < 0)
return std::nullopt;
return exePath;
#elif defined(OS_MACOS)
std::string result;
{
auto string = getMacExecutableDirectoryPath();
result = string;
macFree(string);
}
return result;
#else
return std::nullopt;
#endif
}
bool isPathWritable(const std::fs::path &path) {
constexpr static auto TestFileName = "__imhex__tmp__";
{
File file(path / TestFileName, File::Mode::Read);
if (file.isValid()) {
if (!file.remove())
return false;
}
}
File file(path / TestFileName, File::Mode::Create);
bool result = file.isValid();
if (!file.remove())
return false;
return result;
}
bool openFileBrowser(DialogMode mode, const std::vector<nfdfilteritem_t> &validExtensions, const std::function<void(std::fs::path)> &callback, const std::string &defaultPath) {
NFD::Init();
nfdchar_t *outPath = nullptr;
nfdresult_t result;
switch (mode) {
case DialogMode::Open:
result = NFD::OpenDialog(outPath, validExtensions.data(), validExtensions.size(), defaultPath.c_str());
break;
case DialogMode::Save:
result = NFD::SaveDialog(outPath, validExtensions.data(), validExtensions.size(), defaultPath.c_str());
break;
case DialogMode::Folder:
result = NFD::PickFolder(outPath, defaultPath.c_str());
break;
default:
hex::unreachable();
}
if (result == NFD_OKAY && outPath != nullptr) {
callback(reinterpret_cast<char8_t*>(outPath));
NFD::FreePath(outPath);
}
NFD::Quit();
return result == NFD_OKAY;
}
std::vector<std::fs::path> getDefaultPaths(ImHexPath path, bool listNonExisting) {
std::vector<std::fs::path> result;
const auto exePath = getExecutablePath();
auto userDirs = ImHexApi::System::getAdditionalFolderPaths();
[[maybe_unused]]
auto addUserDirs = [&userDirs](auto &paths) {
std::transform(userDirs.begin(), userDirs.end(), std::back_inserter(paths), [](auto &item) {
return std::move(item);
});
};
#if defined(OS_WINDOWS)
std::fs::path appDataDir;
{
PWSTR wAppDataPath = nullptr;
if (!SUCCEEDED(SHGetKnownFolderPath(FOLDERID_LocalAppData, KF_FLAG_CREATE, nullptr, &wAppDataPath)))
throw std::runtime_error("Failed to get APPDATA folder path");
appDataDir = std::wstring(wAppDataPath);
CoTaskMemFree(wAppDataPath);
}
std::vector<std::fs::path> paths = { appDataDir / "imhex" };
if (exePath)
paths.push_back(exePath->parent_path());
switch (path) {
2022-02-01 22:09:44 +01:00
case ImHexPath::Patterns:
addUserDirs(paths);
2022-02-01 22:09:44 +01:00
std::transform(paths.begin(), paths.end(), std::back_inserter(result), [](auto &path) {
return path / "patterns";
2022-02-01 22:09:44 +01:00
});
break;
case ImHexPath::PatternsInclude:
addUserDirs(paths);
2022-02-01 22:09:44 +01:00
std::transform(paths.begin(), paths.end(), std::back_inserter(result), [](auto &path) {
return path / "includes";
2022-02-01 22:09:44 +01:00
});
break;
case ImHexPath::Magic:
addUserDirs(paths);
2022-02-01 22:09:44 +01:00
std::transform(paths.begin(), paths.end(), std::back_inserter(result), [](auto &path) {
return path / "magic";
2022-02-01 22:09:44 +01:00
});
break;
case ImHexPath::Python:
addUserDirs(paths);
2022-02-01 22:09:44 +01:00
std::transform(paths.begin(), paths.end(), std::back_inserter(result), [](auto &path) {
return path / "python";
2022-02-01 22:09:44 +01:00
});
break;
case ImHexPath::Plugins:
std::transform(paths.begin(), paths.end(), std::back_inserter(result), [](auto &path) {
return path / "plugins";
2022-02-01 22:09:44 +01:00
});
break;
case ImHexPath::Yara:
addUserDirs(paths);
2022-02-01 22:09:44 +01:00
std::transform(paths.begin(), paths.end(), std::back_inserter(result), [](auto &path) {
return path / "yara";
2022-02-01 22:09:44 +01:00
});
break;
case ImHexPath::Config:
return { appDataDir / "imhex" / "config" };
2022-02-01 22:09:44 +01:00
case ImHexPath::Resources:
std::transform(paths.begin(), paths.end(), std::back_inserter(result), [](auto &path) {
return path / "resources";
2022-02-01 22:09:44 +01:00
});
break;
case ImHexPath::Constants:
addUserDirs(paths);
2022-02-01 22:09:44 +01:00
std::transform(paths.begin(), paths.end(), std::back_inserter(result), [](auto &path) {
return path / "constants";
2022-02-01 22:09:44 +01:00
});
break;
case ImHexPath::Encodings:
addUserDirs(paths);
2022-02-01 22:09:44 +01:00
std::transform(paths.begin(), paths.end(), std::back_inserter(result), [](auto &path) {
return path / "encodings";
2022-02-01 22:09:44 +01:00
});
break;
case ImHexPath::Logs:
std::transform(paths.begin(), paths.end(), std::back_inserter(result), [](auto &path) {
return path / "logs";
2022-02-01 22:09:44 +01:00
});
break;
default:
hex::unreachable();
}
#elif defined(OS_MACOS)
// Get path to special directories
std::string applicationSupportDir;
{
auto string = getMacApplicationSupportDirectoryPath();
applicationSupportDir = string;
macFree(string);
}
const std::fs::path applicationSupportDirPath(applicationSupportDir);
std::vector<std::fs::path> paths = { applicationSupportDirPath };
2022-06-17 10:42:54 +02:00
if (exePath.has_value())
2022-06-17 10:31:28 +02:00
paths.push_back(exePath.value());
switch (path) {
2022-02-01 22:09:44 +01:00
case ImHexPath::Patterns:
2022-07-05 00:00:00 +02:00
result.push_back(applicationSupportDirPath / "patterns");
2022-02-01 22:09:44 +01:00
break;
case ImHexPath::PatternsInclude:
2022-07-05 00:00:00 +02:00
result.push_back(applicationSupportDirPath / "includes");
2022-02-01 22:09:44 +01:00
break;
case ImHexPath::Magic:
2022-07-05 00:00:00 +02:00
result.push_back(applicationSupportDirPath / "magic");
2022-02-01 22:09:44 +01:00
break;
case ImHexPath::Python:
2022-07-05 00:00:00 +02:00
result.push_back(applicationSupportDirPath / "python");
2022-02-01 22:09:44 +01:00
break;
case ImHexPath::Plugins:
std::transform(paths.begin(), paths.end(), std::back_inserter(result), [](auto &path) {
2022-07-05 00:00:00 +02:00
return path / "plugins";
2022-02-01 22:09:44 +01:00
});
break;
case ImHexPath::Yara:
2022-07-05 00:00:00 +02:00
result.push_back(applicationSupportDirPath / "yara");
2022-02-01 22:09:44 +01:00
break;
case ImHexPath::Config:
2022-07-05 00:00:00 +02:00
result.push_back(applicationSupportDirPath / "config");
2022-02-01 22:09:44 +01:00
break;
case ImHexPath::Resources:
2022-07-05 00:00:00 +02:00
result.push_back(applicationSupportDirPath / "resources");
2022-02-01 22:09:44 +01:00
break;
case ImHexPath::Constants:
2022-07-05 00:00:00 +02:00
result.push_back(applicationSupportDirPath / "constants");
2022-02-01 22:09:44 +01:00
break;
case ImHexPath::Encodings:
2022-07-05 00:00:00 +02:00
result.push_back(applicationSupportDirPath / "encodings");
2022-02-01 22:09:44 +01:00
break;
case ImHexPath::Logs:
2022-07-05 00:00:00 +02:00
result.push_back(applicationSupportDirPath / "logs");
2022-02-01 22:09:44 +01:00
break;
default:
hex::unreachable();
}
#else
std::vector<std::fs::path> configDirs = xdg::ConfigDirs();
std::vector<std::fs::path> dataDirs = xdg::DataDirs();
configDirs.insert(configDirs.begin(), xdg::ConfigHomeDir());
dataDirs.insert(dataDirs.begin(), xdg::DataHomeDir());
for (auto &dir : dataDirs)
dir = dir / "imhex";
if (exePath && !exePath->empty())
dataDirs.push_back(exePath->parent_path());
switch (path) {
2022-02-01 22:09:44 +01:00
case ImHexPath::Patterns:
addUserDirs(dataDirs);
2022-07-05 00:00:00 +02:00
std::transform(dataDirs.begin(), dataDirs.end(), std::back_inserter(result), [](auto p) { return p / "patterns"; });
2022-02-01 22:09:44 +01:00
break;
case ImHexPath::PatternsInclude:
addUserDirs(dataDirs);
2022-07-05 00:00:00 +02:00
std::transform(dataDirs.begin(), dataDirs.end(), std::back_inserter(result), [](auto p) { return p / "includes"; });
2022-02-01 22:09:44 +01:00
break;
case ImHexPath::Magic:
addUserDirs(dataDirs);
2022-07-05 00:00:00 +02:00
std::transform(dataDirs.begin(), dataDirs.end(), std::back_inserter(result), [](auto p) { return p / "magic"; });
2022-02-01 22:09:44 +01:00
break;
case ImHexPath::Python:
addUserDirs(dataDirs);
2022-07-05 00:00:00 +02:00
std::transform(dataDirs.begin(), dataDirs.end(), std::back_inserter(result), [](auto p) { return p; });
2022-02-01 22:09:44 +01:00
break;
case ImHexPath::Plugins:
2022-07-05 00:00:00 +02:00
std::transform(dataDirs.begin(), dataDirs.end(), std::back_inserter(result), [](auto p) { return p / "plugins"; });
2022-02-01 22:09:44 +01:00
break;
case ImHexPath::Yara:
addUserDirs(dataDirs);
2022-07-05 00:00:00 +02:00
std::transform(dataDirs.begin(), dataDirs.end(), std::back_inserter(result), [](auto p) { return p / "yara"; });
2022-02-01 22:09:44 +01:00
break;
case ImHexPath::Config:
2022-07-05 00:00:00 +02:00
std::transform(configDirs.begin(), configDirs.end(), std::back_inserter(result), [](auto p) { return p / "imhex"; });
2022-02-01 22:09:44 +01:00
break;
case ImHexPath::Resources:
2022-07-05 00:00:00 +02:00
std::transform(dataDirs.begin(), dataDirs.end(), std::back_inserter(result), [](auto p) { return p / "resources"; });
2022-02-01 22:09:44 +01:00
break;
case ImHexPath::Constants:
addUserDirs(dataDirs);
2022-07-05 00:00:00 +02:00
std::transform(dataDirs.begin(), dataDirs.end(), std::back_inserter(result), [](auto p) { return p / "constants"; });
2022-02-01 22:09:44 +01:00
break;
case ImHexPath::Encodings:
addUserDirs(dataDirs);
2022-07-05 00:00:00 +02:00
std::transform(dataDirs.begin(), dataDirs.end(), std::back_inserter(result), [](auto p) { return p / "encodings"; });
2022-02-01 22:09:44 +01:00
break;
case ImHexPath::Logs:
2022-07-05 00:00:00 +02:00
std::transform(dataDirs.begin(), dataDirs.end(), std::back_inserter(result), [](auto p) { return p / "logs"; });
2022-02-01 22:09:44 +01:00
break;
default:
hex::unreachable();
}
#endif
if (!listNonExisting) {
result.erase(std::remove_if(result.begin(), result.end(), [](const auto &path) {
return !fs::isDirectory(path);
2022-02-01 22:09:44 +01:00
}),
result.end());
}
return result;
}
2022-06-30 19:39:06 +02:00
std::fs::path toShortPath(const std::fs::path &path) {
#if defined(OS_WINDOWS)
size_t size = GetShortPathNameW(path.c_str(), nullptr, 0) * sizeof(TCHAR);
if (size == 0)
return path;
std::wstring newPath(size, 0x00);
GetShortPathNameW(path.c_str(), newPath.data(), newPath.size());
return newPath;
#else
return path;
#endif
}
}