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

Address compiler warnings #10
Some checks failed
BlockStorage/repertory_osx/pipeline/head This commit looks good
Details
BlockStorage/repertory_linux_builds/pipeline/head There was a failure building this commit
Details

Browse Source
This commit is contained in:
Scott E. Graves
2023-10-30 13:31:52 -05:00
parent e7413fb741
commit 639d14452b
10 changed files with 1129 additions and 631 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/common.cpp.in
View File

@@ -20,6 +20,7 @@
SOFTWARE.
*/
#include "types/repertory.hpp"
#include "utils/utils.hpp"
namespace repertory {
auto get_repertory_git_revision() -> const std::string & {

10
src/drives/fuse/remotefuse/remote_server.cpp
View File

@@ -601,11 +601,11 @@ auto remote_server::fuse_read(const char *path, char *buffer,
const remote::file_handle &handle)
-> packet::error_type {
const auto file_path = construct_path(path);
auto &b = *reinterpret_cast<data_buffer *>(buffer);
auto &data = *reinterpret_cast<data_buffer *>(buffer);
auto res = has_open_info(static_cast<native_handle>(handle), EBADF);
if (res == 0) {
b.resize(read_size);
res = pread64(static_cast<native_handle>(handle), &b[0], read_size,
data.resize(read_size);
res = pread64(static_cast<native_handle>(handle), data.data(), read_size,
static_cast<off_t>(read_offset));
}
@@ -630,7 +630,7 @@ auto remote_server::fuse_rename(const char *from, const char *to)
auto remote_server::fuse_readdir(const char *path,
const remote::file_offset &offset,
const remote::file_handle &handle,
std::string &itemPath) -> packet::error_type {
std::string &item_path) -> packet::error_type {
const auto file_path = construct_path(path);
auto res = 0;
if (offset > std::numeric_limits<std::size_t>::max()) {
@@ -639,7 +639,7 @@ auto remote_server::fuse_readdir(const char *path,
} else {
auto *iterator = reinterpret_cast<directory_iterator *>(handle);
if (iterator) {
res = iterator->get(static_cast<std::size_t>(offset), itemPath);
res = iterator->get(static_cast<std::size_t>(offset), item_path);
} else {
res = -1;
errno = EFAULT;

206
src/types/remote.cpp
View File

@@ -26,160 +26,92 @@ namespace repertory::remote {
auto create_open_flags(std::uint32_t flags) -> open_flags {
open_flags ret{};
{
const auto f = (flags & 3u);
ret |= (f == 1u) ? open_flags::write_only
: (f == 2u) ? open_flags::read_write
: open_flags::read_only;
}
if (flags & static_cast<std::uint32_t>(O_CREAT)) {
ret |= open_flags::create;
const auto val = (flags & 3U);
ret |= (val == 1U) ? open_flags::write_only
: (val == 2U) ? open_flags::read_write
: open_flags::read_only;
}
if (flags & static_cast<std::uint32_t>(O_EXCL)) {
ret |= open_flags::excl;
}
const auto set_if_has_flag = [&flags, &ret](auto flag, open_flags o_flag) {
if ((flags & static_cast<std::uint32_t>(flag)) != 0U) {
ret |= o_flag;
}
};
if (flags & static_cast<std::uint32_t>(O_NOCTTY)) {
ret |= open_flags::no_ctty;
}
if (flags & static_cast<std::uint32_t>(O_TRUNC)) {
ret |= open_flags::truncate;
}
if (flags & static_cast<std::uint32_t>(O_APPEND)) {
ret |= open_flags::append;
}
if (flags & static_cast<std::uint32_t>(O_NONBLOCK)) {
ret |= open_flags::non_blocking;
}
if (flags & static_cast<std::uint32_t>(O_SYNC)) {
ret |= open_flags::sync;
}
if (flags & static_cast<std::uint32_t>(O_ASYNC)) {
ret |= open_flags::async;
}
if (flags & static_cast<std::uint32_t>(O_DIRECTORY)) {
ret |= open_flags::directory;
}
if (flags & static_cast<std::uint32_t>(O_NOFOLLOW)) {
ret |= open_flags::no_follow;
}
if (flags & static_cast<std::uint32_t>(O_CLOEXEC)) {
ret |= open_flags::clo_exec;
}
set_if_has_flag(O_APPEND, open_flags::append);
set_if_has_flag(O_ASYNC, open_flags::async);
set_if_has_flag(O_CLOEXEC, open_flags::clo_exec);
set_if_has_flag(O_CREAT, open_flags::create);
#ifdef O_DIRECT
if (flags & static_cast<std::uint32_t>(O_DIRECT)) {
ret |= open_flags::direct;
}
#endif
#ifdef O_NOATIME
if (flags & static_cast<std::uint32_t>(O_NOATIME)) {
ret |= open_flags::no_atime;
}
#endif
#ifdef O_PATH
if (flags & static_cast<std::uint32_t>(O_PATH)) {
ret |= open_flags::path;
}
#endif
#ifdef O_TMPFILE
if (flags & static_cast<std::uint32_t>(O_TMPFILE)) {
ret |= open_flags::temp_file;
}
set_if_has_flag(O_DIRECT, open_flags::direct);
#endif
set_if_has_flag(O_DIRECTORY, open_flags::directory);
#ifdef O_DSYNC
if (flags & static_cast<std::uint32_t>(O_DSYNC)) {
ret |= open_flags::dsync;
}
set_if_has_flag(O_DSYNC, open_flags::dsync);
#endif
set_if_has_flag(O_EXCL, open_flags::excl);
#ifdef O_NOATIME
set_if_has_flag(O_NOATIME, open_flags::no_atime);
#endif
set_if_has_flag(O_NOCTTY, open_flags::no_ctty);
set_if_has_flag(O_NOFOLLOW, open_flags::no_follow);
set_if_has_flag(O_NONBLOCK, open_flags::non_blocking);
#ifdef O_PATH
set_if_has_flag(O_PATH, open_flags::path);
#endif
set_if_has_flag(O_SYNC, open_flags::sync);
#ifdef O_TMPFILE
set_if_has_flag(O_TMPFILE, open_flags::temp_file);
#endif
set_if_has_flag(O_TRUNC, open_flags::truncate);
return ret;
}
auto create_os_open_flags(const open_flags &flags) -> std::uint32_t {
std::uint32_t ret = 0u;
if ((flags & open_flags::read_write) == open_flags::read_write) {
ret |= static_cast<std::uint32_t>(O_RDWR);
} else if ((flags & open_flags::write_only) == open_flags::write_only) {
ret |= static_cast<std::uint32_t>(O_WRONLY);
} else {
ret |= static_cast<std::uint32_t>(O_RDONLY);
std::uint32_t ret{};
const auto set_if_has_flag = [&flags, &ret](auto o_flag, auto flag) -> bool {
if ((flags & o_flag) == o_flag) {
ret |= static_cast<std::uint32_t>(flag);
return true;
}
return false;
};
if (not set_if_has_flag(open_flags::read_write, O_RDWR)) {
if (not set_if_has_flag(open_flags::write_only, O_WRONLY)) {
ret |= static_cast<std::uint32_t>(O_RDONLY);
}
}
if ((flags & open_flags::create) == open_flags::create) {
ret |= static_cast<std::uint32_t>(O_CREAT);
}
if ((flags & open_flags::excl) == open_flags::excl) {
ret |= static_cast<std::uint32_t>(O_EXCL);
}
if ((flags & open_flags::no_ctty) == open_flags::no_ctty) {
ret |= static_cast<std::uint32_t>(O_NOCTTY);
}
if ((flags & open_flags::truncate) == open_flags::truncate) {
ret |= static_cast<std::uint32_t>(O_TRUNC);
}
if ((flags & open_flags::append) == open_flags::append) {
ret |= static_cast<std::uint32_t>(O_APPEND);
}
if ((flags & open_flags::non_blocking) == open_flags::non_blocking) {
ret |= static_cast<std::uint32_t>(O_NONBLOCK);
}
if ((flags & open_flags::sync) == open_flags::sync) {
ret |= static_cast<std::uint32_t>(O_SYNC);
}
if ((flags & open_flags::async) == open_flags::async) {
ret |= static_cast<std::uint32_t>(O_ASYNC);
}
if ((flags & open_flags::directory) == open_flags::directory) {
ret |= static_cast<std::uint32_t>(O_DIRECTORY);
}
if ((flags & open_flags::no_follow) == open_flags::no_follow) {
ret |= static_cast<std::uint32_t>(O_NOFOLLOW);
}
if ((flags & open_flags::clo_exec) == open_flags::clo_exec) {
ret |= static_cast<std::uint32_t>(O_CLOEXEC);
}
set_if_has_flag(open_flags::append, O_APPEND);
set_if_has_flag(open_flags::async, O_ASYNC);
set_if_has_flag(open_flags::clo_exec, O_CLOEXEC);
set_if_has_flag(open_flags::create, O_CREAT);
#ifdef O_DIRECT
if ((flags & open_flags::direct) == open_flags::direct) {
ret |= static_cast<std::uint32_t>(O_DIRECT);
}
#endif
#ifdef O_NOATIME
if ((flags & open_flags::no_atime) == open_flags::no_atime) {
ret |= static_cast<std::uint32_t>(O_NOATIME);
}
#endif
#ifdef O_PATH
if ((flags & open_flags::path) == open_flags::path) {
ret |= static_cast<std::uint32_t>(O_PATH);
}
#endif
#ifdef O_TMPFILE
if ((flags & open_flags::temp_file) == open_flags::temp_file) {
ret |= static_cast<std::uint32_t>(O_TMPFILE);
}
set_if_has_flag(open_flags::direct, O_DIRECT);
#endif
set_if_has_flag(open_flags::directory, O_DIRECTORY);
#ifdef O_DSYNC
if ((flags & open_flags::dsync) == open_flags::dsync) {
ret |= static_cast<std::uint32_t>(O_DSYNC);
}
set_if_has_flag(open_flags::dsync, O_DSYNC);
#endif
set_if_has_flag(open_flags::excl, O_EXCL);
#ifdef O_NOATIME
set_if_has_flag(open_flags::no_atime, O_NOATIME);
#endif
set_if_has_flag(open_flags::no_ctty, O_NOCTTY);
set_if_has_flag(open_flags::no_follow, O_NOFOLLOW);
set_if_has_flag(open_flags::non_blocking, O_NONBLOCK);
#ifdef O_PATH
set_if_has_flag(open_flags::path, O_PATH);
#endif
set_if_has_flag(open_flags::sync, O_SYNC);
#ifdef O_TMPFILE
set_if_has_flag(open_flags::temp_file, O_TMPFILE);
#endif
set_if_has_flag(open_flags::truncate, O_TRUNC);
return ret;
}
#endif

101
src/utils/utils.cpp
View File

@@ -44,7 +44,7 @@ void calculate_allocation_size(bool directory, std::uint64_t file_size,
allocation_size = file_size;
}
allocation_size =
((allocation_size == 0u) ? WINFSP_ALLOCATION_UNIT : allocation_size);
((allocation_size == 0U) ? WINFSP_ALLOCATION_UNIT : allocation_size);
allocation_size =
utils::divide_with_ceiling(allocation_size, WINFSP_ALLOCATION_UNIT) *
WINFSP_ALLOCATION_UNIT;
@@ -55,18 +55,18 @@ auto calculate_read_size(const uint64_t &total_size, std::size_t read_size,
const uint64_t &offset) -> std::size_t {
return static_cast<std::size_t>(
((offset + read_size) > total_size)
? ((offset < total_size) ? total_size - offset : 0u)
? ((offset < total_size) ? total_size - offset : 0U)
: read_size);
}
auto compare_version_strings(std::string version1, std::string version2)
-> int {
if (utils::string::contains(version1, "-")) {
version1 = utils::string::split(version1, '-')[0u];
version1 = utils::string::split(version1, '-')[0U];
}
if (utils::string::contains(version2, "-")) {
version2 = utils::string::split(version2, '-')[0u];
version2 = utils::string::split(version2, '-')[0U];
}
auto nums1 = utils::string::split(version1, '.');
@@ -80,11 +80,11 @@ auto compare_version_strings(std::string version1, std::string version2)
nums1.emplace_back("0");
}
for (std::size_t i = 0u; i < nums1.size(); i++) {
for (std::size_t i = 0U; i < nums1.size(); i++) {
const auto int1 = utils::string::to_uint32(nums1[i]);
const auto int2 = utils::string::to_uint32(nums2[i]);
const auto res = std::memcmp(&int1, &int2, sizeof(int1));
if (res) {
if (res != 0) {
return res;
}
}
@@ -105,15 +105,15 @@ auto convert_api_date(const std::string &date) -> std::uint64_t {
#else
strptime(date_time.c_str(), "%Y-%m-%dT%T", &tm1);
#endif
return nanos + (mktime(&tm1) * NANOS_PER_SECOND);
return nanos + (static_cast<std::uint64_t>(mktime(&tm1)) * NANOS_PER_SECOND);
}
auto create_curl() -> CURL * {
static std::recursive_mutex mtx;
unique_recur_mutex_lock l(mtx);
unique_recur_mutex_lock lock(mtx);
curl_global_init(CURL_GLOBAL_DEFAULT);
l.unlock();
lock.unlock();
return reset_curl(curl_easy_init());
}
@@ -132,9 +132,9 @@ auto create_uuid_string() -> std::string {
return ret;
#else
#if __linux__
uuid id;
id.make(UUID_MAKE_V4);
return id.string();
uuid guid;
guid.make(UUID_MAKE_V4);
return guid.string();
#else
uuid_t guid;
uuid_generate_random(guid);
@@ -148,8 +148,8 @@ auto create_uuid_string() -> std::string {
#endif
}
auto create_volume_label(const provider_type &pt) -> std::string {
return "repertory_" + app_config::get_provider_name(pt);
auto create_volume_label(const provider_type &prov) -> std::string {
return "repertory_" + app_config::get_provider_name(prov);
}
auto download_type_from_string(std::string type,
@@ -158,9 +158,13 @@ auto download_type_from_string(std::string type,
type = utils::string::to_lower(utils::string::trim(type));
if (type == "direct") {
return download_type::direct;
} else if (type == "fallback") {
}
if (type == "fallback") {
return download_type::fallback;
} else if (type == "ring_buffer") {
}
if (type == "ring_buffer") {
return download_type::ring_buffer;
}
@@ -192,20 +196,18 @@ auto filetime_to_unix_time(const FILETIME &ft) -> remote::file_time {
}
void unix_time_to_filetime(const remote::file_time &ts, FILETIME &ft) {
const auto winTime = (ts / 100ull) + 116444736000000000ull;
ft.dwHighDateTime = winTime >> 32u;
ft.dwLowDateTime = winTime & 0xFFFFFFFF;
const auto win_time = (ts / 100ULl) + 116444736000000000ull;
ft.dwHighDateTime = win_time >> 32u;
ft.dwLowDateTime = win_time & 0xFFFFFFFF;
}
#endif
auto generate_random_string(std::uint16_t length) -> std::string {
srand(static_cast<unsigned int>(get_time_now()));
std::string ret;
ret.resize(length);
for (std::uint16_t i = 0u; i < length; i++) {
for (std::uint16_t i = 0U; i < length; i++) {
do {
ret[i] = static_cast<char>(rand() % 74 + 48);
ret[i] = static_cast<char>(repertory_rand<std::uint8_t>() % 74 + 48);
} while (((ret[i] >= 91) && (ret[i] <= 96)) ||
((ret[i] >= 58) && (ret[i] <= 64)));
}
@@ -219,17 +221,21 @@ auto get_attributes_from_meta(const api_meta_map &meta) -> DWORD {
auto get_environment_variable(const std::string &variable) -> std::string {
#ifdef _WIN32
std::string value;
std::string val;
auto sz = ::GetEnvironmentVariable(&variable[0], nullptr, 0);
if (sz > 0) {
value.resize(sz);
::GetEnvironmentVariable(&variable[0], &value[0], sz);
val.resize(sz);
::GetEnvironmentVariable(&variable[0], &val[0], sz);
}
return value.c_str();
#else
const auto *v = getenv(variable.c_str());
return std::string(v ? v : "");
static std::mutex mtx{};
mutex_lock lock{mtx};
const auto *val = std::getenv(variable.c_str());
auto ret = std::string(val == nullptr ? "" : val);
return ret;
#endif
}
@@ -253,8 +259,11 @@ void get_local_time_now(struct tm &local_time) {
#ifdef _WIN32
localtime_s(&local_time, &now);
#else
static std::mutex mtx{};
mutex_lock lock{mtx};
const auto *tmp = std::localtime(&now);
if (tmp) {
if (tmp != nullptr) {
memcpy(&local_time, tmp, sizeof(local_time));
}
#endif
@@ -264,18 +273,19 @@ auto get_next_available_port(std::uint16_t first_port,
std::uint16_t &available_port) -> bool {
using namespace boost::asio;
using ip::tcp;
boost::system::error_code ec;
boost::system::error_code error_code;
do {
io_service svc;
tcp::acceptor a(svc);
a.open(tcp::v4(), ec) || a.bind({tcp::v4(), first_port}, ec);
} while (ec && (first_port++ < 65535u));
tcp::acceptor acceptor(svc);
acceptor.open(tcp::v4(), error_code) ||
acceptor.bind({tcp::v4(), first_port}, error_code);
} while (error_code && (first_port++ < 65535U));
if (not ec) {
if (not error_code) {
available_port = first_port;
}
return not ec;
return not error_code;
}
auto get_time_now() -> std::uint64_t {
@@ -305,41 +315,44 @@ auto reset_curl(CURL *curl_handle) -> CURL * {
}
auto retryable_action(const std::function<bool()> &action) -> bool {
static constexpr const auto retry_count = 20U;
auto succeeded = false;
for (std::uint8_t i = 0u; not(succeeded = action()) && (i < 20u); i++) {
for (std::uint8_t i = 0U; not(succeeded = action()) && (i < retry_count);
i++) {
std::this_thread::sleep_for(100ms);
}
return succeeded;
}
void spin_wait_for_mutex(std::function<bool()> complete,
std::condition_variable &cv, std::mutex &mtx,
std::condition_variable &cond, std::mutex &mtx,
const std::string &text) {
while (not complete()) {
unique_mutex_lock l(mtx);
unique_mutex_lock lock(mtx);
if (not complete()) {
if (not text.empty()) {
/* event_system::instance().raise<DebugLog>(__FUNCTION__,
* "spin_wait_for_mutex", text); */
}
cv.wait_for(l, 1s);
cond.wait_for(lock, 1s);
}
l.unlock();
lock.unlock();
}
}
void spin_wait_for_mutex(bool &complete, std::condition_variable &cv,
void spin_wait_for_mutex(bool &complete, std::condition_variable &cond,
std::mutex &mtx, const std::string &text) {
while (not complete) {
unique_mutex_lock l(mtx);
unique_mutex_lock lock(mtx);
if (not complete) {
if (not text.empty()) {
/* event_system::instance().raise<DebugLog>(__FUNCTION__,
* "spin_wait_for_mutex", text); */
}
cv.wait_for(l, 1s);
cond.wait_for(lock, 1s);
}
l.unlock();
lock.unlock();
}
}
} // namespace repertory::utils