v2.0.5-rc (#41)

Reviewed-on: #41

repertory/librepertory/include/app_config.hpp

@@ -43,8 +43,7 @@ public:
   [[nodiscard]] static auto default_remote_api_port(const provider_type &prov)
       -> std::uint16_t;
 
-  [[nodiscard]] static auto default_rpc_port(const provider_type &prov)
-      -> std::uint16_t;
+  [[nodiscard]] static auto default_rpc_port() -> std::uint16_t;
 
   [[nodiscard]] static auto get_provider_display_name(const provider_type &prov)
       -> std::string;
@@ -52,6 +51,8 @@ public:
   [[nodiscard]] static auto get_provider_name(const provider_type &prov)
       -> std::string;
 
+  [[nodiscard]] static auto get_root_data_directory() -> std::string;
+
 public:
   [[nodiscard]] static auto get_stop_requested() -> bool;
 
@@ -71,7 +72,7 @@ public:
 
 private:
   provider_type prov_;
-  atomic<std::string> api_auth_;
+  atomic<std::string> api_password_;
   std::atomic<std::uint16_t> api_port_;
   atomic<std::string> api_user_;
   std::atomic<bool> config_changed_;
@@ -121,7 +122,7 @@ private:
   auto set_value(dest &dst, const source &src) -> bool;
 
 public:
-  [[nodiscard]] auto get_api_auth() const -> std::string;
+  [[nodiscard]] auto get_api_password() const -> std::string;
 
   [[nodiscard]] auto get_api_port() const -> std::uint16_t;
 
@@ -199,7 +200,7 @@ public:
 
   void save();
 
-  void set_api_auth(const std::string &value);
+  void set_api_password(const std::string &value);
 
   void set_api_port(std::uint16_t value);
 

repertory/librepertory/include/common.hpp

@@ -57,7 +57,7 @@ using json = nlohmann::json;
 inline constexpr const std::string_view REPERTORY = "repertory";
 inline constexpr const std::wstring_view REPERTORY_W = L"repertory";
 
-inline constexpr const std::uint64_t REPERTORY_CONFIG_VERSION = 1ULL;
+inline constexpr const std::uint64_t REPERTORY_CONFIG_VERSION = 2ULL;
 inline constexpr const std::string_view REPERTORY_DATA_NAME = "repertory2";
 inline constexpr const std::string_view REPERTORY_MIN_REMOTE_VERSION = "2.0.0";
 

repertory/librepertory/include/platform/platform.hpp

@@ -22,6 +22,13 @@
 #ifndef REPERTORY_INCLUDE_PLATFORM_PLATFORM_HPP_
 #define REPERTORY_INCLUDE_PLATFORM_PLATFORM_HPP_
 
+#include "types/repertory.hpp"
+
+namespace repertory {
+[[nodiscard]] auto create_lock_id(provider_type prov,
+                                  std::string_view unique_id)->std::string;
+}
+
 #if defined(_WIN32)
 #include "platform/win32_platform.hpp"
 #include "utils/windows.hpp"

repertory/librepertory/include/platform/unix_platform.hpp

@@ -30,38 +30,45 @@ class i_provider;
 
 class lock_data final {
 public:
-  explicit lock_data(const provider_type &pt, std::string unique_id /*= ""*/);
+  lock_data(provider_type prov, std::string_view unique_id);
 
-  lock_data();
+  lock_data(const lock_data &) = delete;
+  lock_data(lock_data &&) = delete;
+
+  auto operator=(const lock_data &) -> lock_data & = delete;
+  auto operator=(lock_data &&) -> lock_data & = delete;
 
   ~lock_data();
 
 private:
-  const provider_type pt_;
-  const std::string unique_id_;
-  const std::string mutex_id_;
-  int lock_fd_;
-  int lock_status_ = EWOULDBLOCK;
+  std::string mutex_id_;
+
+private:
+  int handle_{};
+  int lock_status_{EWOULDBLOCK};
 
 private:
   [[nodiscard]] static auto get_state_directory() -> std::string;
 
-  [[nodiscard]] static auto get_lock_data_file() -> std::string;
+  [[nodiscard]] auto get_lock_data_file() const -> std::string;
 
-  [[nodiscard]] auto get_lock_file() -> std::string;
+  [[nodiscard]] auto get_lock_file() const -> std::string;
 
 private:
-  [[nodiscard]] static auto
-  wait_for_lock(int fd, std::uint8_t retry_count = 30u) -> int;
+  [[nodiscard]] static auto wait_for_lock(int handle,
+                                          std::uint8_t retry_count = 30U)
+      -> int;
 
 public:
   [[nodiscard]] auto get_mount_state(json &mount_state) -> bool;
 
-  [[nodiscard]] auto grab_lock(std::uint8_t retry_count = 30u) -> lock_result;
+  [[nodiscard]] auto grab_lock(std::uint8_t retry_count = 30U) -> lock_result;
+
+  void release();
 
   [[nodiscard]] auto set_mount_state(bool active,
-                                     const std::string &mount_location,
-                                     int pid) -> bool;
+                                     std::string_view mount_location, int pid)
+      -> bool;
 };
 
 [[nodiscard]] auto create_meta_attributes(
@@ -76,5 +83,5 @@ public:
                                          const api_file &file) -> api_error;
 } // namespace repertory
 
-#endif // _WIN32
+#endif // !defined(_WIN32)
 #endif // REPERTORY_INCLUDE_PLATFORM_UNIXPLATFORM_HPP_

repertory/librepertory/include/platform/win32_platform.hpp

@@ -23,7 +23,6 @@
 #define REPERTORY_INCLUDE_PLATFORM_WINPLATFORM_HPP_
 #if defined(_WIN32)
 
-#include "app_config.hpp"
 #include "types/repertory.hpp"
 
 namespace repertory {
@@ -31,43 +30,32 @@ class i_provider;
 
 class lock_data final {
 public:
-  explicit lock_data(const provider_type &pt, std::string unique_id /*= ""*/)
-      : pt_(pt),
-        unique_id_(std::move(unique_id)),
-        mutex_id_("repertory_" + app_config::get_provider_name(pt) + "_" +
-                  unique_id_),
-        mutex_handle_(::CreateMutex(nullptr, FALSE, &mutex_id_[0u])) {}
+  explicit lock_data(provider_type prov, std::string unique_id);
+  lock_data(const lock_data &) = delete;
+  lock_data(lock_data &&) = delete;
 
-  lock_data()
-      : pt_(provider_type::sia),
-        unique_id_(""),
-        mutex_id_(""),
-        mutex_handle_(INVALID_HANDLE_VALUE) {}
+  ~lock_data();
 
-  ~lock_data() { release(); }
+  auto operator=(const lock_data &) -> lock_data & = delete;
+  auto operator=(lock_data &&) -> lock_data & = delete;
 
 private:
-  const provider_type pt_;
-  const std::string unique_id_;
-  const std::string mutex_id_;
-  HANDLE mutex_handle_;
-  DWORD mutex_state_ = WAIT_FAILED;
+  std::string mutex_id_;
+  HANDLE mutex_handle_{INVALID_HANDLE_VALUE};
+  DWORD mutex_state_{WAIT_FAILED};
+
+  [[nodiscard]] auto get_current_mount_state(json &mount_state) -> bool;
 
 public:
-  [[nodiscard]] auto get_mount_state(const provider_type &pt,
-                                     json &mount_state) -> bool;
-
   [[nodiscard]] auto get_mount_state(json &mount_state) -> bool;
 
-  [[nodiscard]] auto get_unique_id() const -> std::string { return unique_id_; }
-
-  [[nodiscard]] auto grab_lock(std::uint8_t retry_count = 30) -> lock_result;
+  [[nodiscard]] auto grab_lock(std::uint8_t retry_count = 30U) -> lock_result;
 
   void release();
 
   [[nodiscard]] auto set_mount_state(bool active,
-                                     const std::string &mount_location,
-                                     const std::int64_t &pid) -> bool;
+                                     std::string_view mount_location,
+                                     std::int64_t pid) -> bool;
 };
 
 [[nodiscard]] auto create_meta_attributes(

repertory/librepertory/include/rpc/client/client.hpp

@@ -48,9 +48,9 @@ public:
 
   [[nodiscard]] auto get_pinned_files() -> rpc_response;
 
-  [[nodiscard]] auto pin_file(const std::string &api_file) -> rpc_response;
+  [[nodiscard]] auto pin_file(const std::string &api_path) -> rpc_response;
 
-  [[nodiscard]] auto pinned_status(const std::string &api_file) -> rpc_response;
+  [[nodiscard]] auto pinned_status(const std::string &api_path) -> rpc_response;
 
   [[nodiscard]] auto set_config_value_by_name(const std::string &name,
                                               const std::string &value)
@@ -58,7 +58,7 @@ public:
 
   [[nodiscard]] auto unmount() -> rpc_response;
 
-  [[nodiscard]] auto unpin_file(const std::string &api_file) -> rpc_response;
+  [[nodiscard]] auto unpin_file(const std::string &api_path) -> rpc_response;
 };
 } // namespace repertory
 

repertory/librepertory/include/rpc/common.hpp

@@ -0,0 +1,82 @@
+/*
+  Copyright <2018-2025> <scott.e.graves@protonmail.com>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+#ifndef REPERTORY_INCLUDE_RPC_COMMON_HPP_
+#define REPERTORY_INCLUDE_RPC_COMMON_HPP_
+
+#include "utils/base64.hpp"
+#include "utils/error_utils.hpp"
+#include "utils/string.hpp"
+
+namespace repertory::rpc {
+[[nodiscard]] auto check_authorization(const auto &cfg,
+                                       const httplib::Request &req) -> bool {
+  REPERTORY_USES_FUNCTION_NAME();
+
+  if (cfg.get_api_password().empty() || cfg.get_api_user().empty()) {
+    utils::error::raise_error(function_name,
+                              "authorization user or password is not set");
+    return false;
+  }
+
+  auto authorization = req.get_header_value("Authorization");
+  if (authorization.empty()) {
+    utils::error::raise_error(function_name,
+                              "'Authorization' header is not set");
+    return false;
+  }
+
+  auto auth_parts = utils::string::split(authorization, ' ', true);
+  if (auth_parts.empty()) {
+    utils::error::raise_error(function_name, "'Authorization' header is empty");
+    return false;
+  }
+
+  auto auth_type = auth_parts[0U];
+  if (auth_type != "Basic") {
+    utils::error::raise_error(function_name,
+                              "authorization type is not 'Basic'");
+    return false;
+  }
+
+  auto data = macaron::Base64::Decode(authorization.substr(6U));
+  auto auth_str = std::string(data.begin(), data.end());
+
+  auto auth = utils::string::split(auth_str, ':', false);
+  if (auth.size() < 2U) {
+    utils::error::raise_error(function_name, "authorization data is not valid");
+    return false;
+  }
+
+  auto user = auth.at(0U);
+  auth.erase(auth.begin());
+
+  auto pwd = utils::string::join(auth, ':');
+  if ((user != cfg.get_api_user()) || (pwd != cfg.get_api_password())) {
+    utils::error::raise_error(function_name, "authorization failed");
+    return false;
+  }
+
+  return true;
+}
+} // namespace repertory::rpc
+
+#endif // REPERTORY_INCLUDE_RPC_COMMON_HPP_

repertory/librepertory/include/rpc/server/server.hpp

@@ -40,8 +40,6 @@ private:
   std::mutex start_stop_mutex_;
 
 private:
-  [[nodiscard]] auto check_authorization(const httplib::Request &req) -> bool;
-
   void handle_get_config(const httplib::Request &req, httplib::Response &res);
 
   void handle_get_config_value_by_name(const httplib::Request &req,

repertory/librepertory/include/types/repertory.hpp

@@ -23,7 +23,7 @@
 #define REPERTORY_INCLUDE_TYPES_REPERTORY_HPP_
 
 namespace repertory {
-constexpr const auto default_api_auth_size{48U};
+constexpr const auto default_api_password_size{48U};
 constexpr const auto default_download_timeout_secs{30U};
 constexpr const auto default_eviction_delay_mins{1U};
 constexpr const auto default_high_freq_interval_secs{std::uint16_t{30U}};
@@ -38,6 +38,7 @@ constexpr const auto default_retry_read_count{6U};
 constexpr const auto default_ring_buffer_file_size{512U};
 constexpr const auto default_task_wait_ms{100U};
 constexpr const auto default_timeout_ms{60000U};
+constexpr const auto default_ui_mgmt_port{std::uint16_t{30000U}};
 constexpr const auto max_ring_buffer_file_size{std::uint16_t(1024U)};
 constexpr const auto max_s3_object_name_length{1024U};
 constexpr const auto min_cache_size_bytes{
@@ -280,6 +281,8 @@ enum class exit_code : std::int32_t {
   pin_failed = -16,
   unpin_failed = -17,
   init_failed = -18,
+  ui_mount_failed = -19,
+  exception = -20,
 };
 
 enum http_error_codes : std::int32_t {
@@ -304,6 +307,18 @@ enum class provider_type : std::size_t {
   unknown,
 };
 
+[[nodiscard]] auto
+provider_type_from_string(std::string_view type,
+                          provider_type default_type = provider_type::unknown)
+    -> provider_type;
+
+[[nodiscard]] auto provider_type_to_string(provider_type type) -> std::string;
+
+void clean_json_config(provider_type prov, nlohmann::json &data);
+
+[[nodiscard]] auto clean_json_value(std::string_view name,
+                                    std::string_view data) -> std::string;
+
 #if defined(_WIN32)
 struct open_file_data final {
   PVOID directory_buffer{nullptr};
@@ -452,7 +467,6 @@ using meta_provider_callback = std::function<void(directory_item &)>;
 
 inline constexpr const auto JSON_ACCESS_KEY{"AccessKey"};
 inline constexpr const auto JSON_AGENT_STRING{"AgentString"};
-inline constexpr const auto JSON_API_AUTH{"ApiAuth"};
 inline constexpr const auto JSON_API_PARENT{"ApiParent"};
 inline constexpr const auto JSON_API_PASSWORD{"ApiPassword"};
 inline constexpr const auto JSON_API_PATH{"ApiPath"};
@@ -487,6 +501,7 @@ inline constexpr const auto JSON_MAX_UPLOAD_COUNT{"MaxUploadCount"};
 inline constexpr const auto JSON_MED_FREQ_INTERVAL_SECS{
     "MedFreqIntervalSeconds"};
 inline constexpr const auto JSON_META{"Meta"};
+inline constexpr const auto JSON_MOUNT_LOCATIONS{"MountLocations"};
 inline constexpr const auto JSON_ONLINE_CHECK_RETRY_SECS{
     "OnlineCheckRetrySeconds"};
 inline constexpr const auto JSON_PATH{"Path"};

repertory/librepertory/include/utils/cli_utils.hpp

@@ -49,6 +49,8 @@ static const option password_option = {"-pw", "--password"};
 static const option remote_mount_option = {"-rm", "--remote_mount"};
 static const option set_option = {"-set", "--set"};
 static const option status_option = {"-status", "--status"};
+static const option ui_option = {"-ui", "--ui"};
+static const option ui_port_option = {"-up", "--ui_port"};
 static const option unmount_option = {"-unmount", "--unmount"};
 static const option unpin_file_option = {"-uf", "--unpin_file"};
 static const option user_option = {"-us", "--user"};
@@ -75,6 +77,8 @@ static const std::vector<option> option_list = {
     remote_mount_option,
     set_option,
     status_option,
+    ui_option,
+    ui_port_option,
     unmount_option,
     unpin_file_option,
     user_option,
@@ -87,26 +91,27 @@ void get_api_authentication_data(std::string &user, std::string &password,
                                  std::uint16_t &port, const provider_type &prov,
                                  const std::string &data_directory);
 
-[[nodiscard]] auto
-get_provider_type_from_args(std::vector<const char *> args) -> provider_type;
+[[nodiscard]] auto get_provider_type_from_args(std::vector<const char *> args)
+    -> provider_type;
 
 [[nodiscard]] auto has_option(std::vector<const char *> args,
                               const std::string &option_name) -> bool;
 
-[[nodiscard]] auto has_option(std::vector<const char *> args,
-                              const option &opt) -> bool;
+[[nodiscard]] auto has_option(std::vector<const char *> args, const option &opt)
+    -> bool;
 
 [[nodiscard]] auto parse_option(std::vector<const char *> args,
                                 const std::string &option_name,
                                 std::uint8_t count) -> std::vector<std::string>;
 
 [[nodiscard]] auto parse_string_option(std::vector<const char *> args,
-                                       const option &opt,
-                                       std::string &value) -> exit_code;
+                                       const option &opt, std::string &value)
+    -> exit_code;
 
-[[nodiscard]] auto
-parse_drive_options(std::vector<const char *> args, provider_type &prov,
-                    std::string &data_directory) -> std::vector<std::string>;
+[[nodiscard]] auto parse_drive_options(std::vector<const char *> args,
+                                       provider_type &prov,
+                                       std::string &data_directory)
+    -> std::vector<std::string>;
 } // namespace repertory::utils::cli
 
 #endif // REPERTORY_INCLUDE_UTILS_CLI_UTILS_HPP_