BlockStorage/repertory
1
0
Fork 0
Code Issues 7 Pull Requests Releases 6 Wiki Activity

updated build system
All checks were successful
BlockStorage/repertory/pipeline/head This commit looks good
Details

Browse Source
This commit is contained in:
Scott E. Graves 2024-10-20 12:01:23 -05:00
parent 104e101158
commit 1f6036ec18
17 changed files with 696 additions and 705 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
support/include/utils/collection.hpp
View File

@ -92,11 +92,11 @@ template <typename val_t>
}
if (fmt_val.empty()) {
throw utils::error::create_exception({
function_name,
"hex string is invalid",
str,
});
throw utils::error::create_exception(function_name,
{
"hex string is invalid",
str,
});
}
if (fmt_val.length() % 2U) {

18
support/include/utils/db/sqlite/db_common.hpp
View File

@ -101,10 +101,10 @@ public:
overloaded{
[](const data_type &value) -> data_type { return value; },
[](auto &&) -> data_type {
throw utils::error::create_exception({
function_name,
"data type not supported",
});
throw utils::error::create_exception(
function_name, {
"data type not supported",
});
},
},
value_);
@ -138,11 +138,11 @@ public:
} break;
default:
throw utils::error::create_exception({
function_name,
"column type not implemented",
std::to_string(column_type),
});
throw utils::error::create_exception(function_name,
{
"column type not implemented",
std::to_string(column_type),
});
}
columns_[name] = db_column{col, name, value};

8
support/include/utils/encryption.hpp
View File

@ -124,10 +124,10 @@ encrypt_data(const std::array<unsigned char,
mac.data(), &mac_length, buffer, buffer_size,
reinterpret_cast<const unsigned char *>(&size), sizeof(size), nullptr,
iv.data(), key.data()) != 0) {
throw repertory::utils::error::create_exception({
function_name,
"encryption failed",
});
throw repertory::utils::error::create_exception(function_name,
{
"encryption failed",
});
}
std::memcpy(res.data(), iv.data(), iv.size());

3
support/include/utils/error.hpp
View File

@ -29,7 +29,8 @@ namespace repertory::utils::error {
create_error_message(std::vector<std::string_view> items) -> std::string;
[[nodiscard]] auto
create_exception(std::vector<std::string_view> items) -> std::runtime_error;
create_exception(std::string_view function_name,
std::vector<std::string_view> items) -> std::runtime_error;
struct i_exception_handler {
virtual ~i_exception_handler() {}

36
support/include/utils/hash.hpp
View File

@ -92,32 +92,32 @@ auto create_hash_blake2b_t(const unsigned char *data,
crypto_generichash_blake2b_state state{};
auto res = crypto_generichash_blake2b_init(&state, nullptr, 0U, hash.size());
if (res != 0) {
throw utils::error::create_exception({
function_name,
"failed to initialize blake2b",
std::to_string(hash.size() * 8U),
std::to_string(res),
});
throw utils::error::create_exception(function_name,
{
"failed to initialize blake2b",
std::to_string(hash.size() * 8U),
std::to_string(res),
});
}
res = crypto_generichash_blake2b_update(&state, data, data_size);
if (res != 0) {
throw utils::error::create_exception({
function_name,
"failed to update blake2b",
std::to_string(hash.size() * 8U),
std::to_string(res),
});
throw utils::error::create_exception(function_name,
{
"failed to update blake2b",
std::to_string(hash.size() * 8U),
std::to_string(res),
});
}
res = crypto_generichash_blake2b_final(&state, hash.data(), hash.size());
if (res != 0) {
throw utils::error::create_exception({
function_name,
"failed to finalize blake2b",
std::to_string(hash.size() * 8U),
std::to_string(res),
});
throw utils::error::create_exception(function_name,
{
"failed to finalize blake2b",
std::to_string(hash.size() * 8U),
std::to_string(res),
});
}
return hash;

8
support/include/utils/types/file/i_fs_item.hpp
View File

@ -55,10 +55,10 @@ struct file_times final {
return written;
}
throw utils::error::create_exception({
function_name,
"type_type not supported",
});
throw utils::error::create_exception(function_name,
{
"type_type not supported",
});
}
};

19
support/src/utils/db/sqlite/db_common.cpp
View File

@ -87,12 +87,12 @@ auto create_db(std::string db_path,
SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, nullptr);
if (db_res != SQLITE_OK) {
const auto *msg = sqlite3_errstr(db_res);
throw utils::error::create_exception({
function_name,
"failed to open db",
db_path,
(msg == nullptr ? std::to_string(db_res) : msg),
});
throw utils::error::create_exception(
function_name, {
"failed to open db",
db_path,
(msg == nullptr ? std::to_string(db_res) : msg),
});
}
auto db3 = db3_t{
@ -104,10 +104,9 @@ auto create_db(std::string db_path,
std::string err_msg;
if (not sqlite::execute_sql(*db3, create_item.second, err_msg)) {
db3.reset();
throw utils::error::create_exception({
function_name,
err_msg,
});
throw utils::error::create_exception(function_name, {
err_msg,
});
}
}

91
support/src/utils/encrypting_reader.cpp
View File

@ -63,10 +63,10 @@ protected:
REPERTORY_USES_FUNCTION_NAME();
if ((which & std::ios_base::in) != std::ios_base::in) {
throw utils::error::create_exception({
function_name,
"output is not supported",
});
throw utils::error::create_exception(function_name,
{
"output is not supported",
});
}
const auto set_position = [this](char *next) -> pos_type {
@ -187,11 +187,10 @@ encrypting_reader::encrypting_reader(
REPERTORY_USES_FUNCTION_NAME();
if (not *source_file_) {
throw utils::error::create_exception({
function_name,
"file open failed",
source_path,
});
throw utils::error::create_exception(function_name, {
"file open failed",
source_path,
});
}
data_buffer result;
@ -214,11 +213,11 @@ encrypting_reader::encrypting_reader(
auto opt_size = source_file_->size();
if (not opt_size.has_value()) {
throw utils::error::create_exception({
function_name,
"failed to get file size",
source_file_->get_path(),
});
throw utils::error::create_exception(function_name,
{
"failed to get file size",
source_file_->get_path(),
});
}
auto file_size = opt_size.value();
@ -249,11 +248,10 @@ encrypting_reader::encrypting_reader(std::string_view encrypted_file_path,
REPERTORY_USES_FUNCTION_NAME();
if (not *source_file_) {
throw utils::error::create_exception({
function_name,
"file open failed",
source_path,
});
throw utils::error::create_exception(function_name, {
"file open failed",
source_path,
});
}
encrypted_file_path_ = encrypted_file_path;
@ -261,11 +259,11 @@ encrypting_reader::encrypting_reader(std::string_view encrypted_file_path,
auto opt_size = source_file_->size();
if (not opt_size.has_value()) {
throw utils::error::create_exception({
function_name,
"failed to get file size",
source_file_->get_path(),
});
throw utils::error::create_exception(function_name,
{
"failed to get file size",
source_file_->get_path(),
});
}
auto file_size = opt_size.value();
@ -298,11 +296,10 @@ encrypting_reader::encrypting_reader(
REPERTORY_USES_FUNCTION_NAME();
if (not *source_file_) {
throw utils::error::create_exception({
function_name,
"file open failed",
source_path,
});
throw utils::error::create_exception(function_name, {
"file open failed",
source_path,
});
}
encrypted_file_path_ = encrypted_file_path;
@ -310,12 +307,12 @@ encrypting_reader::encrypting_reader(
auto opt_size = source_file_->size();
if (not opt_size.has_value()) {
throw utils::error::create_exception({
function_name,
"get file size failed",
std::to_string(utils::get_last_error_code()),
source_file_->get_path(),
});
throw utils::error::create_exception(
function_name, {
"get file size failed",
std::to_string(utils::get_last_error_code()),
source_file_->get_path(),
});
}
auto file_size{opt_size.value()};
@ -347,12 +344,12 @@ encrypting_reader::encrypting_reader(const encrypting_reader &reader)
REPERTORY_USES_FUNCTION_NAME();
if (not *source_file_) {
throw utils::error::create_exception({
function_name,
"file open failed",
std::to_string(utils::get_last_error_code()),
source_file_->get_path(),
});
throw utils::error::create_exception(
function_name, {
"file open failed",
std::to_string(utils::get_last_error_code()),
source_file_->get_path(),
});
}
}
@ -370,12 +367,12 @@ auto encrypting_reader::calculate_encrypted_size(std::string_view source_path)
auto opt_size = utils::file::file{source_path}.size();
if (not opt_size.has_value()) {
throw utils::error::create_exception({
function_name,
"get file size failed",
std::to_string(utils::get_last_error_code()),
source_path,
});
throw utils::error::create_exception(
function_name, {
"get file size failed",
std::to_string(utils::get_last_error_code()),
source_path,
});
}
auto file_size{opt_size.value()};

4
support/src/utils/error.cpp
View File

@ -38,8 +38,10 @@ auto create_error_message(std::vector<std::string_view> items) -> std::string {
return stream.str();
}
auto create_exception(std::vector<std::string_view> items)
auto create_exception(std::string_view function_name,
std::vector<std::string_view> items)
-> std::runtime_error {
items.insert(items.begin(), function_name);
return std::runtime_error(create_error_message(items));
}

246
support/src/utils/file.cpp
View File

@ -51,23 +51,23 @@ auto change_to_process_directory() -> bool {
#else // !defined(__APPLE__)
auto res = readlink("/proc/self/exe", path.data(), path.size());
if (res == -1) {
throw utils::error::create_exception({
function_name,
"failed to readlink",
std::to_string(utils::get_last_error_code()),
path,
});
throw utils::error::create_exception(
function_name, {
"failed to readlink",
std::to_string(utils::get_last_error_code()),
path,
});
}
#endif // defined(__APPLE__)
path = utils::path::get_parent_path(path);
res = chdir(path.c_str());
if (res != 0) {
throw utils::error::create_exception({
function_name,
"failed to chdir",
std::to_string(utils::get_last_error_code()),
path,
});
throw utils::error::create_exception(
function_name, {
"failed to chdir",
std::to_string(utils::get_last_error_code()),
path,
});
}
#endif // defined(_WIN32)
@ -113,12 +113,12 @@ auto get_free_drive_space(std::string_view path)
ULARGE_INTEGER li{};
if (not ::GetDiskFreeSpaceEx(std::string{path}.c_str(), &li, nullptr,
nullptr)) {
throw utils::error::create_exception({
function_name,
"failed to get free disk space",
std::to_string(utils::get_last_error_code()),
path,
});
throw utils::error::create_exception(
function_name, {
"failed to get free disk space",
std::to_string(utils::get_last_error_code()),
path,
});
}
return li.QuadPart;
@ -127,12 +127,12 @@ auto get_free_drive_space(std::string_view path)
#if defined(__linux__)
struct statfs64 st {};
if (statfs64(std::string{path}.c_str(), &st) != 0) {
throw utils::error::create_exception({
function_name,
"failed to get free disk space",
std::to_string(utils::get_last_error_code()),
path,
});
throw utils::error::create_exception(
function_name, {
"failed to get free disk space",
std::to_string(utils::get_last_error_code()),
path,
});
}
return st.f_bfree * static_cast<std::uint64_t>(st.f_bsize);
@ -141,12 +141,12 @@ auto get_free_drive_space(std::string_view path)
#if defined(__APPLE__)
struct statvfs st {};
if (statvfs(path.c_str(), &st) != 0) {
throw utils::error::create_exception({
function_name,
"failed to get free disk space",
std::to_string(utils::get_last_error_code()),
path,
});
throw utils::error::create_exception(
function_name, {
"failed to get free disk space",
std::to_string(utils::get_last_error_code()),
path,
});
}
return st.f_bfree * static_cast<std::uint64_t>(st.f_frsize);
@ -209,12 +209,12 @@ auto get_times(std::string_view path) -> std::optional<file_times> {
struct _stat64 st {};
if (_stat64(std::string{path}.c_str(), &st) != 0) {
throw utils::error::create_exception({
function_name,
"failed to get file times",
std::to_string(utils::get_last_error_code()),
path,
});
throw utils::error::create_exception(
function_name, {
"failed to get file times",
std::to_string(utils::get_last_error_code()),
path,
});
}
ret.accessed = utils::time::windows_time_t_to_unix_time(st.st_atime);
@ -224,12 +224,12 @@ auto get_times(std::string_view path) -> std::optional<file_times> {
#else // !defined(_WIN32)
struct stat64 st {};
if (stat64(std::string{path}.c_str(), &st) != 0) {
throw utils::error::create_exception({
function_name,
"failed to get file times",
std::to_string(utils::get_last_error_code()),
path,
});
throw utils::error::create_exception(
function_name, {
"failed to get file times",
std::to_string(utils::get_last_error_code()),
path,
});
}
ret.accessed = static_cast<std::uint64_t>(st.st_atim.tv_nsec) +
@ -270,12 +270,12 @@ auto get_total_drive_space(std::string_view path)
ULARGE_INTEGER li{};
if (not ::GetDiskFreeSpaceEx(std::string{path}.c_str(), nullptr, &li,
nullptr)) {
throw utils::error::create_exception({
function_name,
"failed to get total disk space",
std::to_string(utils::get_last_error_code()),
path,
});
throw utils::error::create_exception(
function_name, {
"failed to get total disk space",
std::to_string(utils::get_last_error_code()),
path,
});
}
return li.QuadPart;
@ -284,12 +284,12 @@ auto get_total_drive_space(std::string_view path)
#if defined(__linux__)
struct statfs64 st {};
if (statfs64(std::string{path}.c_str(), &st) != 0) {
throw utils::error::create_exception({
function_name,
"failed to get total disk space",
std::to_string(utils::get_last_error_code()),
path,
});
throw utils::error::create_exception(
function_name, {
"failed to get total disk space",
std::to_string(utils::get_last_error_code()),
path,
});
}
return st.f_blocks * static_cast<std::uint64_t>(st.f_bsize);
@ -298,12 +298,12 @@ auto get_total_drive_space(std::string_view path)
#if defined(__APPLE__)
struct statvfs st {};
if (statvfs(path.c_str(), &st) != 0) {
throw utils::error::create_exception({
function_name,
"failed to get total disk space",
std::to_string(utils::get_last_error_code()),
path,
});
throw utils::error::create_exception(
function_name, {
"failed to get total disk space",
std::to_string(utils::get_last_error_code()),
path,
});
}
return st.f_blocks * static_cast<std::uint64_t>(st.f_frsize);
@ -424,12 +424,12 @@ auto write_json_file(std::string_view path,
try {
auto file = file::open_or_create_file(path);
if (not file->truncate()) {
throw utils::error::create_exception({
function_name,
"failed to truncate file",
std::to_string(utils::get_last_error_code()),
path,
});
throw utils::error::create_exception(
function_name, {
"failed to truncate file",
std::to_string(utils::get_last_error_code()),
path,
});
}
#if defined(PROJECT_ENABLE_LIBSODIUM) && defined(PROJECT_ENABLE_BOOST)
@ -503,11 +503,10 @@ auto smb_create_smb_path(std::string_view smb_path,
REPERTORY_USES_FUNCTION_NAME();
if (not validate_smb_path(smb_path)) {
throw utils::error::create_exception({
function_name,
"invalid smb path",
smb_path,
});
throw utils::error::create_exception(function_name, {
"invalid smb path",
smb_path,
});
}
std::string path{rel_path};
@ -524,11 +523,10 @@ auto smb_create_smb_path(std::string_view smb_path,
path = "//" + utils::path::format_path(path, "/", "\\");
if (not validate_smb_path(path)) {
throw utils::error::create_exception({
function_name,
"invalid smb path",
path,
});
throw utils::error::create_exception(function_name, {
"invalid smb path",
path,
});
}
return path;
@ -539,23 +537,22 @@ auto smb_create_and_validate_relative_path(
REPERTORY_USES_FUNCTION_NAME();
if (not validate_smb_path(smb_path)) {
throw utils::error::create_exception({
function_name,
"invalid smb path",
smb_path,
});
throw utils::error::create_exception(function_name, {
"invalid smb path",
smb_path,
});
}
std::string dir_path;
if (utils::string::begins_with(path, "//")) {
if (not utils::file::smb_parent_is_same(smb_path, path)) {
throw utils::error::create_exception({
function_name,
"failed to validate path",
"parent paths are not the same",
smb_path,
path,
});
throw utils::error::create_exception(function_name,
{
"failed to validate path",
"parent paths are not the same",
smb_path,
path,
});
}
return utils::file::smb_create_relative_path(path);
@ -569,11 +566,10 @@ auto smb_create_relative_path(std::string_view smb_path) -> std::string {
REPERTORY_USES_FUNCTION_NAME();
if (not validate_smb_path(smb_path)) {
throw utils::error::create_exception({
function_name,
"invalid smb path",
smb_path,
});
throw utils::error::create_exception(function_name, {
"invalid smb path",
smb_path,
});
}
std::string path{smb_path};
@ -589,11 +585,10 @@ auto smb_create_search_path(std::string_view smb_path) -> std::string {
REPERTORY_USES_FUNCTION_NAME();
if (not validate_smb_path(smb_path)) {
throw utils::error::create_exception({
function_name,
"invalid smb path",
smb_path,
});
throw utils::error::create_exception(function_name, {
"invalid smb path",
smb_path,
});
}
std::string path{smb_path};
@ -610,11 +605,10 @@ auto smb_get_parent_path(std::string_view smb_path) -> std::string {
REPERTORY_USES_FUNCTION_NAME();
if (not validate_smb_path(smb_path)) {
throw utils::error::create_exception({
function_name,
"invalid smb path",
smb_path,
});
throw utils::error::create_exception(function_name, {
"invalid smb path",
smb_path,
});
}
auto parts = repertory::utils::string::split(smb_path.substr(2U), '/', false);
@ -624,11 +618,11 @@ auto smb_get_parent_path(std::string_view smb_path) -> std::string {
auto parent_smb_path = "//" + utils::string::join(parts, '/');
if (not validate_smb_path(parent_smb_path)) {
throw utils::error::create_exception({
function_name,
"invalid parent smb path",
parent_smb_path,
});
throw utils::error::create_exception(function_name,
{
"invalid parent smb path",
parent_smb_path,
});
}
return parent_smb_path;
@ -638,11 +632,10 @@ auto smb_get_root_path(std::string_view smb_path) -> std::string {
REPERTORY_USES_FUNCTION_NAME();
if (not validate_smb_path(smb_path)) {
throw utils::error::create_exception({
function_name,
"invalid smb path",
smb_path,
});
throw utils::error::create_exception(function_name, {
"invalid smb path",
smb_path,
});
}
auto parts = repertory::utils::string::split(smb_path.substr(2U), '/', false);
@ -657,11 +650,10 @@ auto smb_get_unc_path(std::string_view smb_path) -> std::string {
REPERTORY_USES_FUNCTION_NAME();
if (not validate_smb_path(smb_path)) {
throw utils::error::create_exception({
function_name,
"invalid smb path",
smb_path,
});
throw utils::error::create_exception(function_name, {
"invalid smb path",
smb_path,
});
}
std::string unc_path{smb_path};
@ -673,11 +665,10 @@ auto smb_get_uri_path(std::string_view smb_path) -> std::string {
REPERTORY_USES_FUNCTION_NAME();
if (not validate_smb_path(smb_path)) {
throw utils::error::create_exception({
function_name,
"invalid smb path",
smb_path,
});
throw utils::error::create_exception(function_name, {
"invalid smb path",
smb_path,
});
}
return "smb:" + std::string{smb_path};
@ -688,11 +679,10 @@ auto smb_get_uri_path(std::string_view smb_path, std::string_view user,
REPERTORY_USES_FUNCTION_NAME();
if (not validate_smb_path(smb_path)) {
throw utils::error::create_exception({
function_name,
"invalid smb path",
smb_path,
});
throw utils::error::create_exception(function_name, {
"invalid smb path",
smb_path,
});
}
return "smb://" + std::string{user} + ':' + std::string{password} + '@' +

64
support/src/utils/file_directory.cpp
View File

@ -46,12 +46,13 @@ auto traverse_directory(
auto search = repertory::utils::path::combine(path, {"*.*"});
auto find = ::FindFirstFileA(search.c_str(), &fd);
if (find == INVALID_HANDLE_VALUE) {
throw repertory::utils::error::create_exception({
throw repertory::utils::error::create_exception(
function_name,
"failed to open directory",
std::to_string(repertory::utils::get_last_error_code()),
path,
});
{
"failed to open directory",
std::to_string(repertory::utils::get_last_error_code()),
path,
});
}
do {
@ -73,12 +74,13 @@ auto traverse_directory(
#else // !defined(_WIN32)
auto *root = opendir(std::string{path}.c_str());
if (root == nullptr) {
throw repertory::utils::error::create_exception({
throw repertory::utils::error::create_exception(
function_name,
"failed to open directory",
std::to_string(repertory::utils::get_last_error_code()),
path,
});
{
"failed to open directory",
std::to_string(repertory::utils::get_last_error_code()),
path,
});
}
struct dirent *de{nullptr};
@ -108,14 +110,14 @@ auto directory::copy_to(std::string_view new_path,
REPERTORY_USES_FUNCTION_NAME();
try {
throw utils::error::create_exception({
function_name,
"failed to copy directory",
"not implemented",
utils::string::from_bool(overwrite),
new_path,
path_,
});
throw utils::error::create_exception(
function_name, {
"failed to copy directory",
"not implemented",
utils::string::from_bool(overwrite),
new_path,
path_,
});
} catch (const std::exception &e) {
utils::error::handle_exception(function_name, e);
} catch (...) {
@ -171,12 +173,12 @@ auto directory::create_directory(std::string_view path) const
auto res = ::SHCreateDirectory(nullptr,
utils::string::from_utf8(abs_path).c_str());
if (res != ERROR_SUCCESS) {
throw utils::error::create_exception({
function_name,
"failed to create directory",
std::to_string(res),
abs_path,
});
throw utils::error::create_exception(function_name,
{
"failed to create directory",
std::to_string(res),
abs_path,
});
}
#else // !defined(_WIN32)
auto ret{true};
@ -377,13 +379,13 @@ auto directory::move_to(std::string_view new_path) -> bool {
REPERTORY_USES_FUNCTION_NAME();
try {
throw utils::error::create_exception({
function_name,
"failed to move directory",
"not implemented",
new_path,
path_,
});
throw utils::error::create_exception(function_name,
{
"failed to move directory",
"not implemented",
new_path,
path_,
});
} catch (const std::exception &e) {
utils::error::handle_exception(function_name, e);
} catch (...) {

135
support/src/utils/file_file.cpp
View File

@ -115,11 +115,10 @@ void file::open() {
REPERTORY_USES_FUNCTION_NAME();
if (not is_file(path_)) {
throw utils::error::create_exception({
function_name,
"file not found",
path_,
});
throw utils::error::create_exception(function_name, {
"file not found",
path_,
});
}
#if defined(_WIN32)
@ -300,20 +299,20 @@ auto file::read(unsigned char *data, std::size_t to_read, std::uint64_t offset,
try {
if (not file_) {
throw utils::error::create_exception({
function_name,
"file is not open for reading",
path_,
});
throw utils::error::create_exception(function_name,
{
"file is not open for reading",
path_,
});
}
if (fseeko(file_.get(), static_cast<std::int64_t>(offset), SEEK_SET) ==
-1) {
throw utils::error::create_exception({
function_name,
"failed to seek before read",
path_,
});
throw utils::error::create_exception(function_name,
{
"failed to seek before read",
path_,
});
}
std::size_t bytes_read{0U};
@ -321,11 +320,11 @@ auto file::read(unsigned char *data, std::size_t to_read, std::uint64_t offset,
auto res =
fread(&data[bytes_read], 1U, to_read - bytes_read, file_.get());
if (not feof(file_.get()) && ferror(file_.get())) {
throw utils::error::create_exception({
function_name,
"failed to read file bytes",
path_,
});
throw utils::error::create_exception(function_name,
{
"failed to read file bytes",
path_,
});
}
if (res == 0) {
@ -367,12 +366,12 @@ auto file::sha256() -> std::optional<std::string> {
crypto_hash_sha256_state state{};
auto res = crypto_hash_sha256_init(&state);
if (res != 0) {
throw utils::error::create_exception({
function_name,
"failed to initialize sha256",
std::to_string(res),
path_,
});
throw utils::error::create_exception(function_name,
{
"failed to initialize sha256",
std::to_string(res),
path_,
});
}
{
@ -389,12 +388,12 @@ auto file::sha256() -> std::optional<std::string> {
&state, reinterpret_cast<const unsigned char *>(buffer.data()),
bytes_read);
if (res != 0) {
throw utils::error::create_exception({
function_name,
"failed to update sha256",
std::to_string(res),
path_,
});
throw utils::error::create_exception(function_name,
{
"failed to update sha256",
std::to_string(res),
path_,
});
}
}
}
@ -402,12 +401,12 @@ auto file::sha256() -> std::optional<std::string> {
std::array<unsigned char, crypto_hash_sha256_BYTES> out{};
res = crypto_hash_sha256_final(&state, out.data());
if (res != 0) {
throw utils::error::create_exception({
function_name,
"failed to finalize sha256",
std::to_string(res),
path_,
});
throw utils::error::create_exception(function_name,
{
"failed to finalize sha256",
std::to_string(res),
path_,
});
}
ret = utils::collection::to_hex_string(out);
@ -497,20 +496,20 @@ auto file::write(const unsigned char *data, std::size_t to_write,
try {
if (not file_) {
throw utils::error::create_exception({
function_name,
"file is not open for writing",
path_,
});
throw utils::error::create_exception(function_name,
{
"file is not open for writing",
path_,
});
}
auto res = fseeko(file_.get(), static_cast<std::int64_t>(offset), SEEK_SET);
if (res == -1) {
throw utils::error::create_exception({
function_name,
"failed to seek before write",
path_,
});
throw utils::error::create_exception(function_name,
{
"failed to seek before write",
path_,
});
}
std::size_t bytes_written{0U};
@ -519,11 +518,11 @@ auto file::write(const unsigned char *data, std::size_t to_write,
fwrite(reinterpret_cast<const char *>(&data[bytes_written]), 1U,
to_write - bytes_written, file_.get());
if (not feof(file_.get()) && ferror(file_.get())) {
throw utils::error::create_exception({
function_name,
"failed to write file bytes",
path_,
});
throw utils::error::create_exception(function_name,
{
"failed to write file bytes",
path_,
});
}
if (written == 0U) {
@ -555,20 +554,20 @@ auto file::size() const -> std::optional<std::uint64_t> {
try {
if (file_) {
if (fseeko(file_.get(), 0, SEEK_END) == -1) {
throw utils::error::create_exception({
function_name,
"failed to seek",
path_,
});
throw utils::error::create_exception(function_name,
{
"failed to seek",
path_,
});
}
auto size = ftello(file_.get());
if (size == -1) {
throw utils::error::create_exception({
function_name,
"failed to get position",
path_,
});
throw utils::error::create_exception(function_name,
{
"failed to get position",
path_,
});
}
return static_cast<std::uint64_t>(size);
@ -576,11 +575,11 @@ auto file::size() const -> std::optional<std::uint64_t> {
std::uint64_t size{};
if (not get_file_size(path_, size)) {
throw utils::error::create_exception({
function_name,
"failed to get file size",
path_,
});
throw utils::error::create_exception(function_name,
{
"failed to get file size",
path_,
});
}
return size;

378
support/src/utils/file_smb_directory.cpp
View File

@ -52,12 +52,12 @@ auto smb_directory::open(std::string_view host, std::string_view user,
if (res != DSM_SUCCESS) {
res = inet_pton(AF_INET, std::string{host}.c_str(), &addr.sin_addr);
if (res != 1) {
throw utils::error::create_exception({
function_name,
"failed to resolve host",
std::to_string(utils::get_last_error_code()),
host,
});
throw utils::error::create_exception(
function_name, {
"failed to resolve host",
std::to_string(utils::get_last_error_code()),
host,
});
}
}
@ -65,12 +65,12 @@ auto smb_directory::open(std::string_view host, std::string_view user,
static_cast<std::uint32_t>(addr.sin_addr.s_addr),
SMB_TRANSPORT_TCP);
if (res != DSM_SUCCESS) {
throw utils::error::create_exception({
function_name,
"failed to connect to host",
std::to_string(res),
host,
});
throw utils::error::create_exception(function_name,
{
"failed to connect to host",
std::to_string(res),
host,
});
}
smb_session_set_creds(session.get(), std::string{host}.c_str(),
@ -78,13 +78,13 @@ auto smb_directory::open(std::string_view host, std::string_view user,
std::string{password}.c_str());
res = smb_session_login(session.get());
if (res != DSM_SUCCESS) {
throw utils::error::create_exception({
function_name,
"failed to logon to host",
std::to_string(res),
host,
user,
});
throw utils::error::create_exception(function_name,
{
"failed to logon to host",
std::to_string(res),
host,
user,
});
}
auto share_name = utils::string::split(path, '/', false).at(0U);
@ -92,12 +92,12 @@ auto smb_directory::open(std::string_view host, std::string_view user,
smb_tid tid{};
res = smb_tree_connect(session.get(), share_name.c_str(), &tid);
if (res != DSM_SUCCESS) {
throw utils::error::create_exception({
function_name,
"failed to connect to share",
std::to_string(res),
share_name,
});
throw utils::error::create_exception(function_name,
{
"failed to connect to share",
std::to_string(res),
share_name,
});
}
return smb_directory_t{
@ -132,22 +132,22 @@ auto smb_directory::copy_to(std::string_view new_path,
try {
if (not session_) {
throw utils::error::create_exception({
function_name,
"session not found",
path_,
});
throw utils::error::create_exception(function_name,
{
"session not found",
path_,
});
}
// auto to_path = utils::path::absolute(new_path);
throw utils::error::create_exception({
function_name,
"failed to copy directory",
"not implemented",
new_path,
path_,
});
throw utils::error::create_exception(function_name,
{
"failed to copy directory",
"not implemented",
new_path,
path_,
});
} catch (const std::exception &e) {
utils::error::handle_exception(function_name, e);
} catch (...) {
@ -162,11 +162,11 @@ auto smb_directory::count(bool recursive) const -> std::uint64_t {
try {
if (not session_) {
throw utils::error::create_exception({
function_name,
"session not found",
path_,
});
throw utils::error::create_exception(function_name,
{
"session not found",
path_,
});
}
smb_stat_list_t list{
@ -179,13 +179,13 @@ auto smb_directory::count(bool recursive) const -> std::uint64_t {
return count;
}
throw utils::error::create_exception({
function_name,
"failed to get directory count recursively",
"not implemented",
utils::string::from_bool(recursive),
path_,
});
throw utils::error::create_exception(
function_name, {
"failed to get directory count recursively",
"not implemented",
utils::string::from_bool(recursive),
path_,
});
} catch (const std::exception &e) {
utils::error::handle_exception(function_name, e);
} catch (...) {
@ -201,11 +201,11 @@ auto smb_directory::create_directory(std::string_view path) const
try {
if (not session_) {
throw utils::error::create_exception({
function_name,
"session not found",
path_,
});
throw utils::error::create_exception(function_name,
{
"session not found",
path_,
});
}
auto dir = get_directory(path);
@ -217,12 +217,12 @@ auto smb_directory::create_directory(std::string_view path) const
session_.get(), tid_,
smb_create_and_validate_relative_path(path_, path).c_str());
if (res != DSM_SUCCESS) {
throw utils::error::create_exception({
function_name,
"failed to create directory",
std::to_string(res),
path_,
});
throw utils::error::create_exception(function_name,
{
"failed to create directory",
std::to_string(res),
path_,
});
}
return get_directory(path);
@ -241,21 +241,21 @@ auto smb_directory::create_file(std::string_view file_name,
try {
if (not session_) {
throw utils::error::create_exception({
function_name,
"session not found",
path_,
});
throw utils::error::create_exception(function_name,
{
"session not found",
path_,
});
}
auto fs_file = get_file(file_name);
if (fs_file) {
if (not dynamic_cast<smb_file *>(fs_file.get())->open(read_only)) {
throw utils::error::create_exception({
function_name,
"failed to open existing file",
file_name,
});
throw utils::error::create_exception(function_name,
{
"failed to open existing file",
file_name,
});
}
return fs_file;
@ -293,11 +293,11 @@ auto smb_directory::exists() const -> bool {
try {
if (not session_) {
throw utils::error::create_exception({
function_name,
"session not found",
path_,
});
throw utils::error::create_exception(function_name,
{
"session not found",
path_,
});
}
smb_stat_t st{
@ -325,11 +325,11 @@ auto smb_directory::get_directory(std::string_view path) const
try {
if (not session_) {
throw utils::error::create_exception({
function_name,
"session not found",
path_,
});
throw utils::error::create_exception(function_name,
{
"session not found",
path_,
});
}
auto rel_path = smb_create_and_validate_relative_path(path_, path);
@ -338,22 +338,22 @@ auto smb_directory::get_directory(std::string_view path) const
smb_stat_deleter(),
};
if (not st) {
throw utils::error::create_exception({
function_name,
"failed to stat directory",
rel_path,
path_,
});
throw utils::error::create_exception(function_name,
{
"failed to stat directory",
rel_path,
path_,
});
}
bool is_dir{smb_stat_get(st.get(), SMB_STAT_ISDIR) != 0U};
if (not is_dir) {
throw utils::error::create_exception({
function_name,
"path is not a directory",
rel_path,
path_,
});
throw utils::error::create_exception(function_name,
{
"path is not a directory",
rel_path,
path_,
});
}
return smb_directory_t{
@ -379,11 +379,11 @@ auto smb_directory::get_directories() const -> std::vector<fs_directory_t> {
try {
if (not session_) {
throw utils::error::create_exception({
function_name,
"session not found",
path_,
});
throw utils::error::create_exception(function_name,
{
"session not found",
path_,
});
}
smb_stat_list_t list{
smb_find(session_.get(), tid_, smb_create_search_path(path_).c_str()),
@ -391,11 +391,11 @@ auto smb_directory::get_directories() const -> std::vector<fs_directory_t> {
smb_stat_list_deleter(),
};
if (not list) {
throw utils::error::create_exception({
function_name,
"failed to get directory list",
path_,
});
throw utils::error::create_exception(function_name,
{
"failed to get directory list",
path_,
});
}
std::vector<fs_directory_t> ret{};
@ -446,11 +446,11 @@ auto smb_directory::get_file(std::string_view path) const -> fs_file_t {
try {
if (not session_) {
throw utils::error::create_exception({
function_name,
"session not found",
path_,
});
throw utils::error::create_exception(function_name,
{
"session not found",
path_,
});
}
auto rel_path = smb_create_and_validate_relative_path(path_, path);
@ -459,22 +459,22 @@ auto smb_directory::get_file(std::string_view path) const -> fs_file_t {
smb_stat_deleter(),
};
if (not st) {
throw utils::error::create_exception({
function_name,
"failed to stat file",
rel_path,
path_,
});
throw utils::error::create_exception(function_name,
{
"failed to stat file",
rel_path,
path_,
});
}
bool is_dir{smb_stat_get(st.get(), SMB_STAT_ISDIR) != 0U};
if (is_dir) {
throw utils::error::create_exception({
function_name,
"path is not a file",
rel_path,
path_,
});
throw utils::error::create_exception(function_name,
{
"path is not a file",
rel_path,
path_,
});
}
return std::make_unique<smb_file>(
@ -494,11 +494,11 @@ auto smb_directory::get_files() const -> std::vector<fs_file_t> {
try {
if (not session_) {
throw utils::error::create_exception({
function_name,
"session not found",
path_,
});
throw utils::error::create_exception(function_name,
{
"session not found",
path_,
});
}
smb_stat_list_t list{
@ -506,11 +506,11 @@ auto smb_directory::get_files() const -> std::vector<fs_file_t> {
smb_stat_list_deleter(),
};
if (not list) {
throw utils::error::create_exception({
function_name,
"failed to get file list",
path_,
});
throw utils::error::create_exception(function_name,
{
"failed to get file list",
path_,
});
}
std::vector<fs_file_t> ret{};
@ -551,11 +551,11 @@ auto smb_directory::get_items() const -> std::vector<fs_item_t> {
try {
if (not session_) {
throw utils::error::create_exception({
function_name,
"session not found",
path_,
});
throw utils::error::create_exception(function_name,
{
"session not found",
path_,
});
}
smb_stat_list_t list{
@ -563,11 +563,11 @@ auto smb_directory::get_items() const -> std::vector<fs_item_t> {
smb_stat_list_deleter(),
};
if (not list) {
throw utils::error::create_exception({
function_name,
"failed to get item list",
path_,
});
throw utils::error::create_exception(function_name,
{
"failed to get item list",
path_,
});
}
std::vector<fs_item_t> ret{};
@ -636,11 +636,11 @@ auto smb_directory::is_symlink() const -> bool {
try {
if (not session_) {
throw utils::error::create_exception({
function_name,
"session not found",
path_,
});
throw utils::error::create_exception(function_name,
{
"session not found",
path_,
});
}
} catch (const std::exception &e) {
@ -657,20 +657,20 @@ auto smb_directory::move_to(std::string_view new_path) -> bool {
try {
if (not session_) {
throw utils::error::create_exception({
function_name,
"session not found",
path_,
});
throw utils::error::create_exception(function_name,
{
"session not found",
path_,
});
}
throw utils::error::create_exception({
function_name,
"failed to move directory",
"not implemented",
new_path,
path_,
});
throw utils::error::create_exception(function_name,
{
"failed to move directory",
"not implemented",
new_path,
path_,
});
} catch (const std::exception &e) {
utils::error::handle_exception(function_name, e);
} catch (...) {
@ -685,11 +685,11 @@ auto smb_directory::remove() -> bool {
try {
if (not session_) {
throw utils::error::create_exception({
function_name,
"session not found",
path_,
});
throw utils::error::create_exception(function_name,
{
"session not found",
path_,
});
}
return utils::retry_action([this]() -> bool {
@ -701,12 +701,12 @@ auto smb_directory::remove() -> bool {
auto res = smb_directory_rm(session_.get(), tid_,
smb_create_relative_path(path_).c_str());
if (res != DSM_SUCCESS) {
throw utils::error::create_exception({
function_name,
"failed to remove directory",
std::to_string(res),
path_,
});
throw utils::error::create_exception(function_name,
{
"failed to remove directory",
std::to_string(res),
path_,
});
}
return true;
@ -732,23 +732,23 @@ auto smb_directory::remove_recursively() -> bool {
try {
if (not session_) {
throw utils::error::create_exception({
function_name,
"session not found",
path_,
});
throw utils::error::create_exception(function_name,
{
"session not found",
path_,
});
}
if (not exists()) {
return true;
}
throw utils::error::create_exception({
function_name,
"failed to remove directory recursively",
"not implemented",
path_,
});
throw utils::error::create_exception(
function_name, {
"failed to remove directory recursively",
"not implemented",
path_,
});
} catch (const std::exception &e) {
utils::error::handle_exception(function_name, e);
} catch (...) {
@ -763,19 +763,19 @@ auto smb_directory::size(bool /* recursive */) const -> std::uint64_t {
try {
if (not session_) {
throw utils::error::create_exception({
function_name,
"session not found",
path_,
});
throw utils::error::create_exception(function_name,
{
"session not found",
path_,
});
}
throw utils::error::create_exception({
function_name,
"failed to get directory size",
"not implemented",
path_,
});
throw utils::error::create_exception(function_name,
{
"failed to get directory size",
"not implemented",
path_,
});
} catch (const std::exception &e) {
utils::error::handle_exception(function_name, e);
} catch (...) {

303
support/src/utils/file_smb_file.cpp
View File

@ -41,23 +41,23 @@ auto smb_file::copy_to(std::string_view new_path,
try {
if (not session_) {
throw utils::error::create_exception({
function_name,
"session not found",
path_,
});
throw utils::error::create_exception(function_name,
{
"session not found",
path_,
});
}
// auto to_path = utils::path::absolute(new_path);
throw utils::error::create_exception({
function_name,
"failed to copy file",
"not implemented",
std::to_string(overwrite),
new_path,
path_,
});
throw utils::error::create_exception(function_name,
{
"failed to copy file",
"not implemented",
std::to_string(overwrite),
new_path,
path_,
});
} catch (const std::exception &e) {
utils::error::handle_exception(function_name, e);
} catch (...) {
@ -72,11 +72,11 @@ auto smb_file::exists() const -> bool {
try {
if (not session_) {
throw utils::error::create_exception({
function_name,
"session not found",
path_,
});
throw utils::error::create_exception(function_name,
{
"session not found",
path_,
});
}
smb_stat_t st{
@ -102,12 +102,12 @@ void smb_file::flush() const {
REPERTORY_USES_FUNCTION_NAME();
try {
throw utils::error::create_exception({
function_name,
"failed to flush file",
"not implemented",
path_,
});
throw utils::error::create_exception(function_name,
{
"failed to flush file",
"not implemented",
path_,
});
} catch (const std::exception &e) {
utils::error::handle_exception(function_name, e);
} catch (...) {
@ -121,11 +121,11 @@ auto smb_file::get_time(smb_session *session, smb_tid tid, std::string path,
try {
if (session == nullptr) {
throw utils::error::create_exception({
function_name,
"session not found",
path,
});
throw utils::error::create_exception(function_name,
{
"session not found",
path,
});
}
auto rel_path = smb_create_relative_path(path);
@ -134,13 +134,13 @@ auto smb_file::get_time(smb_session *session, smb_tid tid, std::string path,
smb_stat_deleter(),
};
if (not st) {
throw utils::error::create_exception({
function_name,
"failed to stat file",
"not implemented",
rel_path,
path,
});
throw utils::error::create_exception(function_name,
{
"failed to stat file",
"not implemented",
rel_path,
path,
});
}
switch (type) {
@ -170,11 +170,11 @@ auto smb_file::is_symlink() const -> bool {
try {
if (not session_) {
throw utils::error::create_exception({
function_name,
"session not found",
path_,
});
throw utils::error::create_exception(function_name,
{
"session not found",
path_,
});
}
} catch (const std::exception &e) {
@ -191,13 +191,13 @@ auto smb_file::move_to(std::string_view new_path) -> bool {
try {
if (utils::string::begins_with(new_path, "//")) {
throw utils::error::create_exception({
function_name,
"failed to move file",
"new path must be in same share",
new_path,
path_,
});
throw utils::error::create_exception(function_name,
{
"failed to move file",
"new path must be in same share",
new_path,
path_,
});
}
auto from_path = smb_create_relative_path(path_);
@ -214,24 +214,24 @@ auto smb_file::move_to(std::string_view new_path) -> bool {
auto res = smb_tree_connect(session_.get(), share_name_.c_str(), &tid_);
if (res != DSM_SUCCESS) {
throw utils::error::create_exception({
function_name,
"failed to connect to share",
std::to_string(res),
share_name_,
path_,
});
throw utils::error::create_exception(function_name,
{
"failed to connect to share",
std::to_string(res),
share_name_,
path_,
});
}
res = smb_file_mv(session_.get(), tid_, from_path.c_str(), to_path.c_str());
if (res != DSM_SUCCESS) {
throw utils::error::create_exception({
function_name,
"failed to move file",
std::to_string(res),
from_path,
to_path,
});
throw utils::error::create_exception(function_name,
{
"failed to move file",
std::to_string(res),
from_path,
to_path,
});
}
path_ = smb_create_smb_path(path_, to_path);
@ -265,27 +265,27 @@ auto smb_file::open(bool read_only) -> bool {
auto res = smb_tree_connect(session_.get(), share_name_.c_str(), &tid_);
if (res != DSM_SUCCESS) {
throw utils::error::create_exception({
function_name,
"failed to connect to share",
std::to_string(res),
share_name_,
path_,
});
throw utils::error::create_exception(function_name,
{
"failed to connect to share",
std::to_string(res),
share_name_,
path_,
});
}
smb_fd fd{};
res = smb_fopen(session_.get(), tid_, rel_path.c_str(),
read_only ? SMB_MOD_RO : SMB_MOD_RW2, &fd);
if (res != DSM_SUCCESS) {
throw utils::error::create_exception({
function_name,
"failed to open file",
std::to_string(res),
utils::string::from_bool(read_only),
rel_path,
path_,
});
throw utils::error::create_exception(
function_name, {
"failed to open file",
std::to_string(res),
utils::string::from_bool(read_only),
rel_path,
path_,
});
}
fd_ = fd;
@ -311,24 +311,24 @@ auto smb_file::read(unsigned char *data, std::size_t to_read,
}
if (not fd_.has_value()) {
throw utils::error::create_exception({
function_name,
"failed to read file",
"file not open",
path_,
});
throw utils::error::create_exception(function_name,
{
"failed to read file",
"file not open",
path_,
});
}
auto res = smb_fseek(session_.get(), *fd_, static_cast<off_t>(offset),
SMB_SEEK_SET);
if (res == -1) {
throw utils::error::create_exception({
function_name,
"failed to seek file",
std::to_string(res),
std::to_string(offset),
path_,
});
throw utils::error::create_exception(function_name,
{
"failed to seek file",
std::to_string(res),
std::to_string(offset),
path_,
});
}
std::size_t bytes_read{0U};
@ -336,14 +336,14 @@ auto smb_file::read(unsigned char *data, std::size_t to_read,
res = smb_fread(session_.get(), *fd_, &data[bytes_read],
to_read - bytes_read);
if (res == -1) {
throw utils::error::create_exception({
function_name,
"failed to read file",
std::to_string(res),
std::to_string(offset),
std::to_string(to_read),
path_,
});
throw utils::error::create_exception(function_name,
{
"failed to read file",
std::to_string(res),
std::to_string(offset),
std::to_string(to_read),
path_,
});
}
if (res == 0) {
@ -381,26 +381,27 @@ auto smb_file::remove() -> bool {
try {
auto res = smb_tree_connect(session_.get(), share_name_.c_str(), &tid_);
if (res != DSM_SUCCESS) {
throw utils::error::create_exception({
function_name,
"failed to connect to share",
std::to_string(res),
share_name_,
path_,
});
throw utils::error::create_exception(function_name,
{
"failed to connect to share",
std::to_string(res),
share_name_,
path_,
});
}
auto rel_path = smb_create_relative_path(path_);
res = smb_file_rm(session_.get(), tid_, rel_path.c_str());
if (res != DSM_SUCCESS) {
throw utils::error::create_exception({
throw utils::error::create_exception(
function_name,
"failed to remove file",
std::to_string(res),
std::to_string(smb_session_get_nt_status(session_.get())),
rel_path,
path_,
});
{
"failed to remove file",
std::to_string(res),
std::to_string(smb_session_get_nt_status(session_.get())),
rel_path,
path_,
});
}
return true;
@ -426,11 +427,11 @@ auto smb_file::size() const -> std::optional<std::uint64_t> {
try {
if (not session_) {
throw utils::error::create_exception({
function_name,
"session not found",
path_,
});
throw utils::error::create_exception(function_name,
{
"session not found",
path_,
});
}
auto rel_path = smb_create_relative_path(path_);
@ -439,12 +440,12 @@ auto smb_file::size() const -> std::optional<std::uint64_t> {
smb_stat_deleter(),
};
if (not st) {
throw utils::error::create_exception({
function_name,
"failed to stat directory",
rel_path,
path_,
});
throw utils::error::create_exception(function_name,
{
"failed to stat directory",
rel_path,
path_,
});
}
return smb_stat_get(st.get(), SMB_STAT_SIZE);
@ -461,13 +462,13 @@ auto smb_file::truncate(std::size_t size) -> bool {
REPERTORY_USES_FUNCTION_NAME();
try {
throw utils::error::create_exception({
function_name,
"failed to truncate file",
"not implemented",
std::to_string(size),
path_,
});
throw utils::error::create_exception(function_name,
{
"failed to truncate file",
"not implemented",
std::to_string(size),
path_,
});
} catch (const std::exception &e) {
utils::error::handle_exception(function_name, e);
} catch (...) {
@ -487,24 +488,24 @@ auto smb_file::write(const unsigned char *data, std::size_t to_write,
}
if (not fd_.has_value()) {
throw utils::error::create_exception({
function_name,
"failed to write file",
"file not open",
path_,
});
throw utils::error::create_exception(function_name,
{
"failed to write file",
"file not open",
path_,
});
}
auto res = smb_fseek(session_.get(), *fd_, static_cast<off_t>(offset),
SMB_SEEK_SET);
if (res == -1) {
throw utils::error::create_exception({
function_name,
"failed to seek file",
std::to_string(res),
std::to_string(offset),
path_,
});
throw utils::error::create_exception(function_name,
{
"failed to seek file",
std::to_string(res),
std::to_string(offset),
path_,
});
}
std::size_t bytes_written{0U};
@ -513,14 +514,14 @@ auto smb_file::write(const unsigned char *data, std::size_t to_write,
const_cast<unsigned char *>(&data[bytes_written]),
to_write - bytes_written);
if (res == -1) {
throw utils::error::create_exception({
function_name,
"failed to write file",
std::to_string(res),
std::to_string(offset),
std::to_string(to_write),
path_,
});
throw utils::error::create_exception(function_name,
{
"failed to write file",
std::to_string(res),
std::to_string(offset),
std::to_string(to_write),
path_,
});
}
if (res == 0) {

60
support/src/utils/hash.cpp
View File

@ -120,29 +120,29 @@ auto create_hash_sha512(const unsigned char *data,
crypto_hash_sha512_state state{};
auto res = crypto_hash_sha512_init(&state);
if (res != 0) {
throw utils::error::create_exception({
function_name,
"failed to initialize sha-512",
std::to_string(res),
});
throw utils::error::create_exception(function_name,
{
"failed to initialize sha-512",
std::to_string(res),
});
}
res = crypto_hash_sha512_update(&state, data, data_size);
if (res != 0) {
throw utils::error::create_exception({
function_name,
"failed to update sha-512",
std::to_string(res),
});
throw utils::error::create_exception(function_name,
{
"failed to update sha-512",
std::to_string(res),
});
}
res = crypto_hash_sha512_final(&state, hash.data());
if (res != 0) {
throw utils::error::create_exception({
function_name,
"failed to finalize sha-512",
std::to_string(res),
});
throw utils::error::create_exception(function_name,
{
"failed to finalize sha-512",
std::to_string(res),
});
}
return hash;
@ -157,29 +157,29 @@ auto create_hash_sha256(const unsigned char *data,
crypto_hash_sha256_state state{};
auto res = crypto_hash_sha256_init(&state);
if (res != 0) {
throw utils::error::create_exception({
function_name,
"failed to initialize sha-256",
std::to_string(res),
});
throw utils::error::create_exception(function_name,
{
"failed to initialize sha-256",
std::to_string(res),
});
}
res = crypto_hash_sha256_update(&state, data, data_size);
if (res != 0) {
throw utils::error::create_exception({
function_name,
"failed to update sha-256",
std::to_string(res),
});
throw utils::error::create_exception(function_name,
{
"failed to update sha-256",
std::to_string(res),
});
}
res = crypto_hash_sha256_final(&state, hash.data());
if (res != 0) {
throw utils::error::create_exception({
function_name,
"failed to finalize sha-256",
std::to_string(res),
});
throw utils::error::create_exception(function_name,
{
"failed to finalize sha-256",
std::to_string(res),
});
}
return hash;

10
support/src/utils/path.cpp
View File

@ -65,11 +65,11 @@ namespace {
}
});
if (res) {
throw repertory::utils::error::create_exception({
function_name,
"failed to getpwuid",
res.reason,
});
throw repertory::utils::error::create_exception(function_name,
{
"failed to getpwuid",
res.reason,
});
}
path = repertory::utils::string::replace(path, "~/", home + "/");

8
support/src/utils/windows.cpp
View File

@ -74,10 +74,10 @@ auto get_local_app_data_directory() -> const std::string & {
return ret;
}
throw utils::error::create_exception({
function_name,
"unable to detect local application data folder",
});
throw utils::error::create_exception(
function_name, {
"unable to detect local application data folder",
});
})();
return app_data;