99ceb03a1c
This formats all copyright comments according to SPDX formatting guidelines. Additionally, this resolves the remaining GPLv2 only licensed files by relicensing them to GPLv2.0-or-later.
625 lines
18 KiB
C++
625 lines
18 KiB
C++
// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
#include "common/fs/file.h"
|
|
#include "common/fs/fs.h"
|
|
#include "common/fs/path_util.h"
|
|
#include "common/logging/log.h"
|
|
|
|
namespace Common::FS {
|
|
|
|
namespace fs = std::filesystem;
|
|
|
|
// File Operations
|
|
|
|
bool NewFile(const fs::path& path, u64 size) {
|
|
if (!ValidatePath(path)) {
|
|
LOG_ERROR(Common_Filesystem, "Input path is not valid, path={}", PathToUTF8String(path));
|
|
return false;
|
|
}
|
|
|
|
if (!Exists(path.parent_path())) {
|
|
LOG_ERROR(Common_Filesystem, "Parent directory of path={} does not exist",
|
|
PathToUTF8String(path));
|
|
return false;
|
|
}
|
|
|
|
if (Exists(path)) {
|
|
LOG_ERROR(Common_Filesystem, "Filesystem object at path={} exists", PathToUTF8String(path));
|
|
return false;
|
|
}
|
|
|
|
IOFile io_file{path, FileAccessMode::Write};
|
|
|
|
if (!io_file.IsOpen()) {
|
|
LOG_ERROR(Common_Filesystem, "Failed to create a file at path={}", PathToUTF8String(path));
|
|
return false;
|
|
}
|
|
|
|
if (!io_file.SetSize(size)) {
|
|
LOG_ERROR(Common_Filesystem, "Failed to resize the file at path={} to size={}",
|
|
PathToUTF8String(path), size);
|
|
return false;
|
|
}
|
|
|
|
io_file.Close();
|
|
|
|
LOG_DEBUG(Common_Filesystem, "Successfully created a file at path={} with size={}",
|
|
PathToUTF8String(path), size);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool RemoveFile(const fs::path& path) {
|
|
if (!ValidatePath(path)) {
|
|
LOG_ERROR(Common_Filesystem, "Input path is not valid, path={}", PathToUTF8String(path));
|
|
return false;
|
|
}
|
|
|
|
if (!Exists(path)) {
|
|
LOG_DEBUG(Common_Filesystem, "Filesystem object at path={} does not exist",
|
|
PathToUTF8String(path));
|
|
return true;
|
|
}
|
|
|
|
if (!IsFile(path)) {
|
|
LOG_ERROR(Common_Filesystem, "Filesystem object at path={} is not a file",
|
|
PathToUTF8String(path));
|
|
return false;
|
|
}
|
|
|
|
std::error_code ec;
|
|
|
|
fs::remove(path, ec);
|
|
|
|
if (ec) {
|
|
LOG_ERROR(Common_Filesystem, "Failed to remove the file at path={}, ec_message={}",
|
|
PathToUTF8String(path), ec.message());
|
|
return false;
|
|
}
|
|
|
|
LOG_DEBUG(Common_Filesystem, "Successfully removed the file at path={}",
|
|
PathToUTF8String(path));
|
|
|
|
return true;
|
|
}
|
|
|
|
bool RenameFile(const fs::path& old_path, const fs::path& new_path) {
|
|
if (!ValidatePath(old_path) || !ValidatePath(new_path)) {
|
|
LOG_ERROR(Common_Filesystem,
|
|
"One or both input path(s) is not valid, old_path={}, new_path={}",
|
|
PathToUTF8String(old_path), PathToUTF8String(new_path));
|
|
return false;
|
|
}
|
|
|
|
if (!Exists(old_path)) {
|
|
LOG_ERROR(Common_Filesystem, "Filesystem object at old_path={} does not exist",
|
|
PathToUTF8String(old_path));
|
|
return false;
|
|
}
|
|
|
|
if (!IsFile(old_path)) {
|
|
LOG_ERROR(Common_Filesystem, "Filesystem object at old_path={} is not a file",
|
|
PathToUTF8String(old_path));
|
|
return false;
|
|
}
|
|
|
|
if (Exists(new_path)) {
|
|
LOG_ERROR(Common_Filesystem, "Filesystem object at new_path={} exists",
|
|
PathToUTF8String(new_path));
|
|
return false;
|
|
}
|
|
|
|
std::error_code ec;
|
|
|
|
fs::rename(old_path, new_path, ec);
|
|
|
|
if (ec) {
|
|
LOG_ERROR(Common_Filesystem,
|
|
"Failed to rename the file from old_path={} to new_path={}, ec_message={}",
|
|
PathToUTF8String(old_path), PathToUTF8String(new_path), ec.message());
|
|
return false;
|
|
}
|
|
|
|
LOG_DEBUG(Common_Filesystem, "Successfully renamed the file from old_path={} to new_path={}",
|
|
PathToUTF8String(old_path), PathToUTF8String(new_path));
|
|
|
|
return true;
|
|
}
|
|
|
|
std::shared_ptr<IOFile> FileOpen(const fs::path& path, FileAccessMode mode, FileType type,
|
|
FileShareFlag flag) {
|
|
if (!ValidatePath(path)) {
|
|
LOG_ERROR(Common_Filesystem, "Input path is not valid, path={}", PathToUTF8String(path));
|
|
return nullptr;
|
|
}
|
|
|
|
if (Exists(path) && !IsFile(path)) {
|
|
LOG_ERROR(Common_Filesystem,
|
|
"Filesystem object at path={} exists and is not a regular file",
|
|
PathToUTF8String(path));
|
|
return nullptr;
|
|
}
|
|
|
|
auto io_file = std::make_shared<IOFile>(path, mode, type, flag);
|
|
|
|
if (!io_file->IsOpen()) {
|
|
io_file.reset();
|
|
|
|
LOG_ERROR(Common_Filesystem,
|
|
"Failed to open the file at path={} with mode={}, type={}, flag={}",
|
|
PathToUTF8String(path), mode, type, flag);
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
LOG_DEBUG(Common_Filesystem,
|
|
"Successfully opened the file at path={} with mode={}, type={}, flag={}",
|
|
PathToUTF8String(path), mode, type, flag);
|
|
|
|
return io_file;
|
|
}
|
|
|
|
// Directory Operations
|
|
|
|
bool CreateDir(const fs::path& path) {
|
|
if (!ValidatePath(path)) {
|
|
LOG_ERROR(Common_Filesystem, "Input path is not valid, path={}", PathToUTF8String(path));
|
|
return false;
|
|
}
|
|
|
|
if (!Exists(path.parent_path())) {
|
|
LOG_ERROR(Common_Filesystem, "Parent directory of path={} does not exist",
|
|
PathToUTF8String(path));
|
|
return false;
|
|
}
|
|
|
|
if (IsDir(path)) {
|
|
LOG_DEBUG(Common_Filesystem, "Filesystem object at path={} exists and is a directory",
|
|
PathToUTF8String(path));
|
|
return true;
|
|
}
|
|
|
|
std::error_code ec;
|
|
|
|
fs::create_directory(path, ec);
|
|
|
|
if (ec) {
|
|
LOG_ERROR(Common_Filesystem, "Failed to create the directory at path={}, ec_message={}",
|
|
PathToUTF8String(path), ec.message());
|
|
return false;
|
|
}
|
|
|
|
LOG_DEBUG(Common_Filesystem, "Successfully created the directory at path={}",
|
|
PathToUTF8String(path));
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CreateDirs(const fs::path& path) {
|
|
if (!ValidatePath(path)) {
|
|
LOG_ERROR(Common_Filesystem, "Input path is not valid, path={}", PathToUTF8String(path));
|
|
return false;
|
|
}
|
|
|
|
if (IsDir(path)) {
|
|
LOG_DEBUG(Common_Filesystem, "Filesystem object at path={} exists and is a directory",
|
|
PathToUTF8String(path));
|
|
return true;
|
|
}
|
|
|
|
std::error_code ec;
|
|
|
|
fs::create_directories(path, ec);
|
|
|
|
if (ec) {
|
|
LOG_ERROR(Common_Filesystem, "Failed to create the directories at path={}, ec_message={}",
|
|
PathToUTF8String(path), ec.message());
|
|
return false;
|
|
}
|
|
|
|
LOG_DEBUG(Common_Filesystem, "Successfully created the directories at path={}",
|
|
PathToUTF8String(path));
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CreateParentDir(const fs::path& path) {
|
|
return CreateDir(path.parent_path());
|
|
}
|
|
|
|
bool CreateParentDirs(const fs::path& path) {
|
|
return CreateDirs(path.parent_path());
|
|
}
|
|
|
|
bool RemoveDir(const fs::path& path) {
|
|
if (!ValidatePath(path)) {
|
|
LOG_ERROR(Common_Filesystem, "Input path is not valid, path={}", PathToUTF8String(path));
|
|
return false;
|
|
}
|
|
|
|
if (!Exists(path)) {
|
|
LOG_DEBUG(Common_Filesystem, "Filesystem object at path={} does not exist",
|
|
PathToUTF8String(path));
|
|
return true;
|
|
}
|
|
|
|
if (!IsDir(path)) {
|
|
LOG_ERROR(Common_Filesystem, "Filesystem object at path={} is not a directory",
|
|
PathToUTF8String(path));
|
|
return false;
|
|
}
|
|
|
|
std::error_code ec;
|
|
|
|
fs::remove(path, ec);
|
|
|
|
if (ec) {
|
|
LOG_ERROR(Common_Filesystem, "Failed to remove the directory at path={}, ec_message={}",
|
|
PathToUTF8String(path), ec.message());
|
|
return false;
|
|
}
|
|
|
|
LOG_DEBUG(Common_Filesystem, "Successfully removed the directory at path={}",
|
|
PathToUTF8String(path));
|
|
|
|
return true;
|
|
}
|
|
|
|
bool RemoveDirRecursively(const fs::path& path) {
|
|
if (!ValidatePath(path)) {
|
|
LOG_ERROR(Common_Filesystem, "Input path is not valid, path={}", PathToUTF8String(path));
|
|
return false;
|
|
}
|
|
|
|
if (!Exists(path)) {
|
|
LOG_DEBUG(Common_Filesystem, "Filesystem object at path={} does not exist",
|
|
PathToUTF8String(path));
|
|
return true;
|
|
}
|
|
|
|
if (!IsDir(path)) {
|
|
LOG_ERROR(Common_Filesystem, "Filesystem object at path={} is not a directory",
|
|
PathToUTF8String(path));
|
|
return false;
|
|
}
|
|
|
|
std::error_code ec;
|
|
|
|
fs::remove_all(path, ec);
|
|
|
|
if (ec) {
|
|
LOG_ERROR(Common_Filesystem,
|
|
"Failed to remove the directory and its contents at path={}, ec_message={}",
|
|
PathToUTF8String(path), ec.message());
|
|
return false;
|
|
}
|
|
|
|
LOG_DEBUG(Common_Filesystem, "Successfully removed the directory and its contents at path={}",
|
|
PathToUTF8String(path));
|
|
|
|
return true;
|
|
}
|
|
|
|
bool RemoveDirContentsRecursively(const fs::path& path) {
|
|
if (!ValidatePath(path)) {
|
|
LOG_ERROR(Common_Filesystem, "Input path is not valid, path={}", PathToUTF8String(path));
|
|
return false;
|
|
}
|
|
|
|
if (!Exists(path)) {
|
|
LOG_DEBUG(Common_Filesystem, "Filesystem object at path={} does not exist",
|
|
PathToUTF8String(path));
|
|
return true;
|
|
}
|
|
|
|
if (!IsDir(path)) {
|
|
LOG_ERROR(Common_Filesystem, "Filesystem object at path={} is not a directory",
|
|
PathToUTF8String(path));
|
|
return false;
|
|
}
|
|
|
|
std::error_code ec;
|
|
|
|
// TODO (Morph): Replace this with recursive_directory_iterator once it's fixed in MSVC.
|
|
for (const auto& entry : fs::directory_iterator(path, ec)) {
|
|
if (ec) {
|
|
LOG_ERROR(Common_Filesystem,
|
|
"Failed to completely enumerate the directory at path={}, ec_message={}",
|
|
PathToUTF8String(path), ec.message());
|
|
break;
|
|
}
|
|
|
|
fs::remove(entry.path(), ec);
|
|
|
|
if (ec) {
|
|
LOG_ERROR(Common_Filesystem,
|
|
"Failed to remove the filesystem object at path={}, ec_message={}",
|
|
PathToUTF8String(entry.path()), ec.message());
|
|
break;
|
|
}
|
|
|
|
// TODO (Morph): Remove this when MSVC fixes recursive_directory_iterator.
|
|
// recursive_directory_iterator throws an exception despite passing in a std::error_code.
|
|
if (entry.status().type() == fs::file_type::directory) {
|
|
return RemoveDirContentsRecursively(entry.path());
|
|
}
|
|
}
|
|
|
|
if (ec) {
|
|
LOG_ERROR(Common_Filesystem,
|
|
"Failed to remove all the contents of the directory at path={}, ec_message={}",
|
|
PathToUTF8String(path), ec.message());
|
|
return false;
|
|
}
|
|
|
|
LOG_DEBUG(Common_Filesystem,
|
|
"Successfully removed all the contents of the directory at path={}",
|
|
PathToUTF8String(path));
|
|
|
|
return true;
|
|
}
|
|
|
|
bool RenameDir(const fs::path& old_path, const fs::path& new_path) {
|
|
if (!ValidatePath(old_path) || !ValidatePath(new_path)) {
|
|
LOG_ERROR(Common_Filesystem,
|
|
"One or both input path(s) is not valid, old_path={}, new_path={}",
|
|
PathToUTF8String(old_path), PathToUTF8String(new_path));
|
|
return false;
|
|
}
|
|
|
|
if (!Exists(old_path)) {
|
|
LOG_ERROR(Common_Filesystem, "Filesystem object at old_path={} does not exist",
|
|
PathToUTF8String(old_path));
|
|
return false;
|
|
}
|
|
|
|
if (!IsDir(old_path)) {
|
|
LOG_ERROR(Common_Filesystem, "Filesystem object at old_path={} is not a directory",
|
|
PathToUTF8String(old_path));
|
|
return false;
|
|
}
|
|
|
|
if (Exists(new_path)) {
|
|
LOG_ERROR(Common_Filesystem, "Filesystem object at new_path={} exists",
|
|
PathToUTF8String(new_path));
|
|
return false;
|
|
}
|
|
|
|
std::error_code ec;
|
|
|
|
fs::rename(old_path, new_path, ec);
|
|
|
|
if (ec) {
|
|
LOG_ERROR(Common_Filesystem,
|
|
"Failed to rename the file from old_path={} to new_path={}, ec_message={}",
|
|
PathToUTF8String(old_path), PathToUTF8String(new_path), ec.message());
|
|
return false;
|
|
}
|
|
|
|
LOG_DEBUG(Common_Filesystem, "Successfully renamed the file from old_path={} to new_path={}",
|
|
PathToUTF8String(old_path), PathToUTF8String(new_path));
|
|
|
|
return true;
|
|
}
|
|
|
|
void IterateDirEntries(const std::filesystem::path& path, const DirEntryCallable& callback,
|
|
DirEntryFilter filter) {
|
|
if (!ValidatePath(path)) {
|
|
LOG_ERROR(Common_Filesystem, "Input path is not valid, path={}", PathToUTF8String(path));
|
|
return;
|
|
}
|
|
|
|
if (!Exists(path)) {
|
|
LOG_ERROR(Common_Filesystem, "Filesystem object at path={} does not exist",
|
|
PathToUTF8String(path));
|
|
return;
|
|
}
|
|
|
|
if (!IsDir(path)) {
|
|
LOG_ERROR(Common_Filesystem, "Filesystem object at path={} is not a directory",
|
|
PathToUTF8String(path));
|
|
return;
|
|
}
|
|
|
|
bool callback_error = false;
|
|
|
|
std::error_code ec;
|
|
|
|
for (const auto& entry : fs::directory_iterator(path, ec)) {
|
|
if (ec) {
|
|
break;
|
|
}
|
|
|
|
if (True(filter & DirEntryFilter::File) &&
|
|
entry.status().type() == fs::file_type::regular) {
|
|
if (!callback(entry.path())) {
|
|
callback_error = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (True(filter & DirEntryFilter::Directory) &&
|
|
entry.status().type() == fs::file_type::directory) {
|
|
if (!callback(entry.path())) {
|
|
callback_error = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (callback_error || ec) {
|
|
LOG_ERROR(Common_Filesystem,
|
|
"Failed to visit all the directory entries of path={}, ec_message={}",
|
|
PathToUTF8String(path), ec.message());
|
|
return;
|
|
}
|
|
|
|
LOG_DEBUG(Common_Filesystem, "Successfully visited all the directory entries of path={}",
|
|
PathToUTF8String(path));
|
|
}
|
|
|
|
void IterateDirEntriesRecursively(const std::filesystem::path& path,
|
|
const DirEntryCallable& callback, DirEntryFilter filter) {
|
|
if (!ValidatePath(path)) {
|
|
LOG_ERROR(Common_Filesystem, "Input path is not valid, path={}", PathToUTF8String(path));
|
|
return;
|
|
}
|
|
|
|
if (!Exists(path)) {
|
|
LOG_ERROR(Common_Filesystem, "Filesystem object at path={} does not exist",
|
|
PathToUTF8String(path));
|
|
return;
|
|
}
|
|
|
|
if (!IsDir(path)) {
|
|
LOG_ERROR(Common_Filesystem, "Filesystem object at path={} is not a directory",
|
|
PathToUTF8String(path));
|
|
return;
|
|
}
|
|
|
|
bool callback_error = false;
|
|
|
|
std::error_code ec;
|
|
|
|
// TODO (Morph): Replace this with recursive_directory_iterator once it's fixed in MSVC.
|
|
for (const auto& entry : fs::directory_iterator(path, ec)) {
|
|
if (ec) {
|
|
break;
|
|
}
|
|
|
|
if (True(filter & DirEntryFilter::File) &&
|
|
entry.status().type() == fs::file_type::regular) {
|
|
if (!callback(entry.path())) {
|
|
callback_error = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (True(filter & DirEntryFilter::Directory) &&
|
|
entry.status().type() == fs::file_type::directory) {
|
|
if (!callback(entry.path())) {
|
|
callback_error = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// TODO (Morph): Remove this when MSVC fixes recursive_directory_iterator.
|
|
// recursive_directory_iterator throws an exception despite passing in a std::error_code.
|
|
if (entry.status().type() == fs::file_type::directory) {
|
|
IterateDirEntriesRecursively(entry.path(), callback, filter);
|
|
}
|
|
}
|
|
|
|
if (callback_error || ec) {
|
|
LOG_ERROR(Common_Filesystem,
|
|
"Failed to visit all the directory entries of path={}, ec_message={}",
|
|
PathToUTF8String(path), ec.message());
|
|
return;
|
|
}
|
|
|
|
LOG_DEBUG(Common_Filesystem, "Successfully visited all the directory entries of path={}",
|
|
PathToUTF8String(path));
|
|
}
|
|
|
|
// Generic Filesystem Operations
|
|
|
|
bool Exists(const fs::path& path) {
|
|
return fs::exists(path);
|
|
}
|
|
|
|
bool IsFile(const fs::path& path) {
|
|
return fs::is_regular_file(path);
|
|
}
|
|
|
|
bool IsDir(const fs::path& path) {
|
|
return fs::is_directory(path);
|
|
}
|
|
|
|
fs::path GetCurrentDir() {
|
|
std::error_code ec;
|
|
|
|
const auto current_path = fs::current_path(ec);
|
|
|
|
if (ec) {
|
|
LOG_ERROR(Common_Filesystem, "Failed to get the current path, ec_message={}", ec.message());
|
|
return {};
|
|
}
|
|
|
|
return current_path;
|
|
}
|
|
|
|
bool SetCurrentDir(const fs::path& path) {
|
|
std::error_code ec;
|
|
|
|
fs::current_path(path, ec);
|
|
|
|
if (ec) {
|
|
LOG_ERROR(Common_Filesystem, "Failed to set the current path to path={}, ec_message={}",
|
|
PathToUTF8String(path), ec.message());
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
fs::file_type GetEntryType(const fs::path& path) {
|
|
std::error_code ec;
|
|
|
|
const auto file_status = fs::status(path, ec);
|
|
|
|
if (ec) {
|
|
LOG_ERROR(Common_Filesystem, "Failed to retrieve the entry type of path={}, ec_message={}",
|
|
PathToUTF8String(path), ec.message());
|
|
return fs::file_type::not_found;
|
|
}
|
|
|
|
return file_status.type();
|
|
}
|
|
|
|
u64 GetSize(const fs::path& path) {
|
|
std::error_code ec;
|
|
|
|
const auto file_size = fs::file_size(path, ec);
|
|
|
|
if (ec) {
|
|
LOG_ERROR(Common_Filesystem, "Failed to retrieve the file size of path={}, ec_message={}",
|
|
PathToUTF8String(path), ec.message());
|
|
return 0;
|
|
}
|
|
|
|
return file_size;
|
|
}
|
|
|
|
u64 GetFreeSpaceSize(const fs::path& path) {
|
|
std::error_code ec;
|
|
|
|
const auto space_info = fs::space(path, ec);
|
|
|
|
if (ec) {
|
|
LOG_ERROR(Common_Filesystem,
|
|
"Failed to retrieve the available free space of path={}, ec_message={}",
|
|
PathToUTF8String(path), ec.message());
|
|
return 0;
|
|
}
|
|
|
|
return space_info.free;
|
|
}
|
|
|
|
u64 GetTotalSpaceSize(const fs::path& path) {
|
|
std::error_code ec;
|
|
|
|
const auto space_info = fs::space(path, ec);
|
|
|
|
if (ec) {
|
|
LOG_ERROR(Common_Filesystem,
|
|
"Failed to retrieve the total capacity of path={}, ec_message={}",
|
|
PathToUTF8String(path), ec.message());
|
|
return 0;
|
|
}
|
|
|
|
return space_info.capacity;
|
|
}
|
|
|
|
} // namespace Common::FS
|