initial commit

src/comm/packet/client_pool.cpp

@@ -0,0 +1,150 @@
+/*
+  Copyright <2018-2022> <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.
+*/
+#include "comm/packet/client_pool.hpp"
+#include "events/events.hpp"
+#include "events/event_system.hpp"
+
+namespace repertory {
+void client_pool::pool::execute(const std::uint64_t &thread_id, const worker_callback &worker,
+                                const worker_complete_callback &worker_complete) {
+  const auto index = static_cast<std::size_t>(thread_id % pool_queues_.size());
+  auto wi = std::make_shared<work_item>(worker, worker_complete);
+  auto &pool_queue = pool_queues_[index];
+
+  unique_mutex_lock queue_lock(pool_queue->mutex);
+  pool_queue->queue.emplace_back(wi);
+  pool_queue->notify.notify_all();
+  queue_lock.unlock();
+}
+
+client_pool::pool::pool(const std::uint8_t &pool_size) {
+  thread_index_ = 0u;
+  for (std::uint8_t i = 0u; i < pool_size; i++) {
+    pool_queues_.emplace_back(std::make_unique<work_queue>());
+  }
+
+  for (std::size_t i = 0u; i < pool_queues_.size(); i++) {
+    pool_threads_.emplace_back(std::thread([this]() {
+      const auto thread_index = thread_index_++;
+
+      auto &pool_queue = pool_queues_[thread_index];
+      auto &queue = pool_queue->queue;
+      auto &queue_mutex = pool_queue->mutex;
+      auto &queue_notify = pool_queue->notify;
+
+      unique_mutex_lock queue_lock(queue_mutex);
+      queue_notify.notify_all();
+      queue_lock.unlock();
+      while (not shutdown_) {
+        queue_lock.lock();
+        if (queue.empty()) {
+          queue_notify.wait(queue_lock);
+        }
+
+        while (not queue.empty()) {
+          auto workItem = queue.front();
+          queue.pop_front();
+          queue_notify.notify_all();
+          queue_lock.unlock();
+
+          try {
+            const auto result = workItem->work();
+            workItem->work_complete(result);
+          } catch (const std::exception &e) {
+            workItem->work_complete(utils::translate_api_error(api_error::error));
+            event_system::instance().raise<repertory_exception>(__FUNCTION__,
+                                                              e.what() ? e.what() : "unknown");
+          }
+
+          queue_lock.lock();
+        }
+
+        queue_notify.notify_all();
+        queue_lock.unlock();
+      }
+
+      queue_lock.lock();
+      while (not queue.empty()) {
+        auto wi = queue.front();
+        queue.pop_front();
+        queue_notify.notify_all();
+        queue_lock.unlock();
+
+        wi->work_complete(utils::translate_api_error(api_error::download_stopped));
+
+        queue_lock.lock();
+      }
+
+      queue_notify.notify_all();
+      queue_lock.unlock();
+    }));
+  }
+}
+
+void client_pool::pool::shutdown() {
+  shutdown_ = true;
+
+  for (auto &pool_queue : pool_queues_) {
+    unique_mutex_lock l(pool_queue->mutex);
+    pool_queue->notify.notify_all();
+  }
+
+  for (auto &thread : pool_threads_) {
+    thread.join();
+  }
+
+  pool_queues_.clear();
+  pool_threads_.clear();
+}
+
+void client_pool::execute(const std::string &client_id, const std::uint64_t &thread_id,
+                          const worker_callback &worker,
+                          const worker_complete_callback &worker_complete) {
+  unique_mutex_lock pool_lock(pool_mutex_);
+  if (shutdown_) {
+    pool_lock.unlock();
+    throw std::runtime_error("Client pool is shutdown");
+  }
+
+  if (not pool_lookup_[client_id]) {
+    pool_lookup_[client_id] = std::make_shared<pool>(pool_size_);
+  }
+
+  pool_lookup_[client_id]->execute(thread_id, worker, worker_complete);
+  pool_lock.unlock();
+}
+
+void client_pool::remove_client(const std::string &client_id) {
+  mutex_lock pool_lock(pool_mutex_);
+  pool_lookup_.erase(client_id);
+}
+
+void client_pool::shutdown() {
+  unique_mutex_lock pool_lock(pool_mutex_);
+  if (not shutdown_) {
+    shutdown_ = true;
+    event_system::instance().raise<service_shutdown>("client_pool");
+    for (auto &kv : pool_lookup_) {
+      kv.second->shutdown();
+    }
+    pool_lookup_.clear();
+  }
+  pool_lock.unlock();
+}
+} // namespace repertory

src/comm/packet/packet.cpp

@@ -0,0 +1,555 @@
+/*
+  Copyright <2018-2022> <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.
+*/
+#include "comm/packet/packet.hpp"
+#include "events/events.hpp"
+#include "events/event_system.hpp"
+#include "types/remote.hpp"
+#include "types/repertory.hpp"
+#include "utils/encryption.hpp"
+#include "utils/utils.hpp"
+
+namespace repertory {
+void packet::clear() {
+  buffer_.clear();
+  decode_offset_ = 0u;
+}
+
+packet::error_type packet::decode(std::string &data) {
+  const auto *str = &buffer_[decode_offset_];
+  const auto length = strnlen(str, buffer_.size() - decode_offset_);
+  data = std::string(str, length);
+  decode_offset_ += (length + 1);
+
+  return utils::translate_api_error(api_error::success);
+}
+
+packet::error_type packet::decode(std::wstring &data) {
+  std::string utf8_string;
+  const auto ret = decode(utf8_string);
+  if (ret == 0) {
+    data = utils::string::from_utf8(utf8_string);
+  }
+
+  return utils::translate_api_error(api_error::success);
+}
+
+packet::error_type packet::decode(void *&ptr) {
+  return decode(reinterpret_cast<std::uint64_t &>(ptr));
+}
+
+packet::error_type packet::decode(void *buffer, const size_t &size) {
+  if (size) {
+    const auto read_size = utils::calculate_read_size(buffer_.size(), size, decode_offset_);
+    if (read_size == size) {
+      memcpy(buffer, &buffer_[decode_offset_], size);
+      decode_offset_ += size;
+      return utils::translate_api_error(api_error::success);
+    }
+
+    return ((decode_offset_ + size) > buffer_.size())
+               ? utils::translate_api_error(api_error::buffer_overflow)
+               : utils::translate_api_error(api_error::buffer_too_small);
+  }
+  return utils::translate_api_error(api_error::success);
+}
+
+packet::error_type packet::decode(std::int8_t &i) {
+  const auto ret = decode(&i, sizeof(i));
+  if (ret == 0) {
+    boost::endian::big_to_native_inplace(i);
+  }
+  return ret;
+}
+
+packet::error_type packet::decode(std::uint8_t &i) {
+  const auto ret = decode(&i, sizeof(i));
+  if (ret == 0) {
+    boost::endian::big_to_native_inplace(i);
+  }
+  return ret;
+}
+
+packet::error_type packet::decode(std::int16_t &i) {
+  const auto ret = decode(&i, sizeof(i));
+  if (ret == 0) {
+    boost::endian::big_to_native_inplace(i);
+  }
+  return ret;
+}
+
+packet::error_type packet::decode(std::uint16_t &i) {
+  const auto ret = decode(&i, sizeof(i));
+  if (ret == 0) {
+    boost::endian::big_to_native_inplace(i);
+  }
+  return ret;
+}
+
+packet::error_type packet::decode(std::int32_t &i) {
+  const auto ret = decode(&i, sizeof(i));
+  if (ret == 0) {
+    boost::endian::big_to_native_inplace(i);
+  }
+  return ret;
+}
+
+packet::error_type packet::decode(std::uint32_t &i) {
+  const auto ret = decode(&i, sizeof(i));
+  if (ret == 0) {
+    boost::endian::big_to_native_inplace(i);
+  }
+  return ret;
+}
+
+packet::error_type packet::decode(std::int64_t &i) {
+  const auto ret = decode(&i, sizeof(i));
+  if (ret == 0) {
+    boost::endian::big_to_native_inplace(i);
+  }
+  return ret;
+}
+
+packet::error_type packet::decode(std::uint64_t &i) {
+  const auto ret = decode(&i, sizeof(i));
+  if (ret == 0) {
+    boost::endian::big_to_native_inplace(i);
+  }
+  return ret;
+}
+
+packet::error_type packet::decode(remote::setattr_x &i) {
+  const auto ret = decode(&i, sizeof(i));
+  if (ret == 0) {
+    boost::endian::big_to_native_inplace(i.acctime);
+    boost::endian::big_to_native_inplace(i.bkuptime);
+    boost::endian::big_to_native_inplace(i.chgtime);
+    boost::endian::big_to_native_inplace(i.crtime);
+    boost::endian::big_to_native_inplace(i.flags);
+    boost::endian::big_to_native_inplace(i.gid);
+    boost::endian::big_to_native_inplace(i.mode);
+    boost::endian::big_to_native_inplace(i.modtime);
+    boost::endian::big_to_native_inplace(i.size);
+    boost::endian::big_to_native_inplace(i.uid);
+    boost::endian::big_to_native_inplace(i.valid);
+  }
+
+  return ret;
+}
+
+packet::error_type packet::decode(remote::stat &i) {
+  const auto ret = decode(&i, sizeof(i));
+  if (ret == 0) {
+    boost::endian::big_to_native_inplace(i.st_mode);
+    boost::endian::big_to_native_inplace(i.st_nlink);
+    boost::endian::big_to_native_inplace(i.st_uid);
+    boost::endian::big_to_native_inplace(i.st_gid);
+    boost::endian::big_to_native_inplace(i.st_atimespec);
+    boost::endian::big_to_native_inplace(i.st_mtimespec);
+    boost::endian::big_to_native_inplace(i.st_ctimespec);
+    boost::endian::big_to_native_inplace(i.st_birthtimespec);
+    boost::endian::big_to_native_inplace(i.st_size);
+    boost::endian::big_to_native_inplace(i.st_blocks);
+    boost::endian::big_to_native_inplace(i.st_blksize);
+    boost::endian::big_to_native_inplace(i.st_flags);
+  }
+
+  return ret;
+}
+
+packet::error_type packet::decode(remote::statfs &i) {
+  const auto ret = decode(&i, sizeof(i));
+  if (ret == 0) {
+    boost::endian::big_to_native_inplace(i.f_bavail);
+    boost::endian::big_to_native_inplace(i.f_bfree);
+    boost::endian::big_to_native_inplace(i.f_blocks);
+    boost::endian::big_to_native_inplace(i.f_favail);
+    boost::endian::big_to_native_inplace(i.f_ffree);
+    boost::endian::big_to_native_inplace(i.f_files);
+  }
+  return ret;
+}
+
+packet::error_type packet::decode(remote::statfs_x &i) {
+  auto ret = decode(*dynamic_cast<remote::statfs *>(&i));
+  if (ret == 0) {
+    ret = decode(&i.f_mntfromname[0], 1024);
+  }
+  return ret;
+}
+
+packet::error_type packet::decode(remote::file_info &i) {
+  const auto ret = decode(&i, sizeof(i));
+  if (ret == 0) {
+    boost::endian::big_to_native_inplace(i.AllocationSize);
+    boost::endian::big_to_native_inplace(i.ChangeTime);
+    boost::endian::big_to_native_inplace(i.CreationTime);
+    boost::endian::big_to_native_inplace(i.EaSize);
+    boost::endian::big_to_native_inplace(i.FileAttributes);
+    boost::endian::big_to_native_inplace(i.FileSize);
+    boost::endian::big_to_native_inplace(i.HardLinks);
+    boost::endian::big_to_native_inplace(i.IndexNumber);
+    boost::endian::big_to_native_inplace(i.LastAccessTime);
+    boost::endian::big_to_native_inplace(i.LastWriteTime);
+    boost::endian::big_to_native_inplace(i.ReparseTag);
+  }
+
+  return ret;
+}
+
+int packet::decode_json(packet &response, json &json_data) {
+  int ret = 0;
+  std::string data;
+  if ((ret = response.decode(data)) == 0) {
+    try {
+      json_data = json::parse(data);
+    } catch (const std::exception &e) {
+      event_system::instance().raise<repertory_exception>(
+          __FUNCTION__, e.what() ? e.what() : "Failed to parse JSON string");
+      ret = -EIO;
+    }
+  }
+
+  return ret;
+}
+
+packet::error_type packet::decrypt(const std::string &token) {
+  auto ret = utils::translate_api_error(api_error::success);
+  try {
+    std::vector<char> result;
+    if (not utils::encryption::decrypt_data(token, &buffer_[decode_offset_],
+                                            buffer_.size() - decode_offset_, result)) {
+      throw std::runtime_error("Decryption failed");
+    }
+    buffer_ = std::move(result);
+    decode_offset_ = 0;
+  } catch (const std::exception &e) {
+    event_system::instance().raise<repertory_exception>(__FUNCTION__, e.what());
+    ret = utils::translate_api_error(api_error::error);
+  }
+
+  return ret;
+}
+
+void packet::encode(const void *buffer, const std::size_t &size, bool should_reserve) {
+  if (size) {
+    if (should_reserve) {
+      buffer_.reserve(buffer_.size() + size);
+    }
+    const auto *char_buffer = reinterpret_cast<const char *>(buffer);
+    buffer_.insert(buffer_.end(), char_buffer, char_buffer + size);
+  }
+}
+
+void packet::encode(const std::string &str) {
+  const auto len = strnlen(&str[0], str.size());
+  buffer_.reserve(len + 1 + buffer_.size());
+  encode(&str[0], len, false);
+  buffer_.emplace_back(0);
+}
+
+void packet::encode(wchar_t *str) { encode(utils::string::to_utf8(str ? str : L"")); }
+
+void packet::encode(const wchar_t *str) { encode(utils::string::to_utf8(str ? str : L"")); }
+
+void packet::encode(const std::wstring &str) { encode(utils::string::to_utf8(str)); }
+
+void packet::encode(std::int8_t i) {
+  boost::endian::native_to_big_inplace(i);
+  encode(&i, sizeof(i), true);
+}
+
+void packet::encode(std::uint8_t i) {
+  boost::endian::native_to_big_inplace(i);
+  encode(&i, sizeof(i), true);
+}
+
+void packet::encode(std::int16_t i) {
+  boost::endian::native_to_big_inplace(i);
+  encode(&i, sizeof(i), true);
+}
+
+void packet::encode(std::uint16_t i) {
+  boost::endian::native_to_big_inplace(i);
+  encode(&i, sizeof(i), true);
+}
+
+void packet::encode(std::int32_t i) {
+  boost::endian::native_to_big_inplace(i);
+  encode(&i, sizeof(i), true);
+}
+
+void packet::encode(std::uint32_t i) {
+  boost::endian::native_to_big_inplace(i);
+  encode(&i, sizeof(i), true);
+}
+
+void packet::encode(std::int64_t i) {
+  boost::endian::native_to_big_inplace(i);
+  encode(&i, sizeof(i), true);
+}
+
+void packet::encode(std::uint64_t i) {
+  boost::endian::native_to_big_inplace(i);
+  encode(&i, sizeof(i), true);
+}
+
+void packet::encode(remote::setattr_x i) {
+  boost::endian::native_to_big_inplace(i.acctime);
+  boost::endian::native_to_big_inplace(i.bkuptime);
+  boost::endian::native_to_big_inplace(i.chgtime);
+  boost::endian::native_to_big_inplace(i.crtime);
+  boost::endian::native_to_big_inplace(i.flags);
+  boost::endian::native_to_big_inplace(i.gid);
+  boost::endian::native_to_big_inplace(i.mode);
+  boost::endian::native_to_big_inplace(i.modtime);
+  boost::endian::native_to_big_inplace(i.size);
+  boost::endian::native_to_big_inplace(i.uid);
+  boost::endian::native_to_big_inplace(i.valid);
+
+  encode(&i, sizeof(i), true);
+}
+
+void packet::encode(remote::stat i) {
+  boost::endian::native_to_big_inplace(i.st_mode);
+  boost::endian::native_to_big_inplace(i.st_nlink);
+  boost::endian::native_to_big_inplace(i.st_uid);
+  boost::endian::native_to_big_inplace(i.st_gid);
+  boost::endian::native_to_big_inplace(i.st_atimespec);
+  boost::endian::native_to_big_inplace(i.st_mtimespec);
+  boost::endian::native_to_big_inplace(i.st_ctimespec);
+  boost::endian::native_to_big_inplace(i.st_birthtimespec);
+  boost::endian::native_to_big_inplace(i.st_size);
+  boost::endian::native_to_big_inplace(i.st_blocks);
+  boost::endian::native_to_big_inplace(i.st_blksize);
+  boost::endian::native_to_big_inplace(i.st_flags);
+
+  encode(&i, sizeof(i), true);
+}
+
+void packet::encode(remote::statfs i, bool should_reserve) {
+  boost::endian::native_to_big_inplace(i.f_bavail);
+  boost::endian::native_to_big_inplace(i.f_bfree);
+  boost::endian::native_to_big_inplace(i.f_blocks);
+  boost::endian::native_to_big_inplace(i.f_favail);
+  boost::endian::native_to_big_inplace(i.f_ffree);
+  boost::endian::native_to_big_inplace(i.f_files);
+
+  encode(&i, sizeof(remote::statfs), should_reserve);
+}
+
+void packet::encode(remote::statfs_x i) {
+  buffer_.reserve(buffer_.size() + sizeof(remote::statfs) + 1024);
+  encode(*dynamic_cast<remote::statfs *>(&i), false);
+  encode(&i.f_mntfromname[0], 1024, false);
+}
+
+void packet::encode(remote::file_info i) {
+  boost::endian::native_to_big_inplace(i.FileAttributes);
+  boost::endian::native_to_big_inplace(i.ReparseTag);
+  boost::endian::native_to_big_inplace(i.AllocationSize);
+  boost::endian::native_to_big_inplace(i.FileSize);
+  boost::endian::native_to_big_inplace(i.CreationTime);
+  boost::endian::native_to_big_inplace(i.LastAccessTime);
+  boost::endian::native_to_big_inplace(i.LastWriteTime);
+  boost::endian::native_to_big_inplace(i.ChangeTime);
+  boost::endian::native_to_big_inplace(i.IndexNumber);
+  boost::endian::native_to_big_inplace(i.HardLinks);
+  boost::endian::native_to_big_inplace(i.EaSize);
+
+  encode(&i, sizeof(i), true);
+}
+
+void packet::encode_top(const void *buffer, const std::size_t &size, bool should_reserve) {
+  if (size) {
+    if (should_reserve) {
+      buffer_.reserve(buffer_.size() + size);
+    }
+    const auto *char_buffer = reinterpret_cast<const char *>(buffer);
+    buffer_.insert(buffer_.begin(), char_buffer, char_buffer + size);
+  }
+}
+
+void packet::encode_top(const std::string &str) {
+  const auto len = strnlen(&str[0], str.size());
+  buffer_.reserve(len + 1 + buffer_.size());
+  encode_top(&str[0], len, false);
+  buffer_.insert(buffer_.begin() + len, 0);
+}
+
+void packet::encode_top(const std::wstring &str) { encode_top(utils::string::to_utf8(str)); }
+
+void packet::encode_top(std::int8_t i) {
+  boost::endian::native_to_big_inplace(i);
+  encode_top(&i, sizeof(i), true);
+}
+
+void packet::encode_top(std::uint8_t i) {
+  boost::endian::native_to_big_inplace(i);
+  encode_top(&i, sizeof(i), true);
+}
+
+void packet::encode_top(std::int16_t i) {
+  boost::endian::native_to_big_inplace(i);
+  encode_top(&i, sizeof(i), true);
+}
+
+void packet::encode_top(std::uint16_t i) {
+  boost::endian::native_to_big_inplace(i);
+  encode_top(&i, sizeof(i), true);
+}
+
+void packet::encode_top(std::int32_t i) {
+  boost::endian::native_to_big_inplace(i);
+  encode_top(&i, sizeof(i), true);
+}
+
+void packet::encode_top(std::uint32_t i) {
+  boost::endian::native_to_big_inplace(i);
+  encode_top(&i, sizeof(i), true);
+}
+
+void packet::encode_top(std::int64_t i) {
+  boost::endian::native_to_big_inplace(i);
+  encode_top(&i, sizeof(i), true);
+}
+
+void packet::encode_top(std::uint64_t i) {
+  boost::endian::native_to_big_inplace(i);
+  encode_top(&i, sizeof(i), true);
+}
+
+void packet::encode_top(remote::setattr_x i) {
+  boost::endian::native_to_big_inplace(i.acctime);
+  boost::endian::native_to_big_inplace(i.bkuptime);
+  boost::endian::native_to_big_inplace(i.chgtime);
+  boost::endian::native_to_big_inplace(i.crtime);
+  boost::endian::native_to_big_inplace(i.flags);
+  boost::endian::native_to_big_inplace(i.gid);
+  boost::endian::native_to_big_inplace(i.mode);
+  boost::endian::native_to_big_inplace(i.modtime);
+  boost::endian::native_to_big_inplace(i.size);
+  boost::endian::native_to_big_inplace(i.uid);
+  boost::endian::native_to_big_inplace(i.valid);
+
+  encode_top(&i, sizeof(i), true);
+}
+
+void packet::encode_top(remote::stat i) {
+  boost::endian::native_to_big_inplace(i.st_mode);
+  boost::endian::native_to_big_inplace(i.st_nlink);
+  boost::endian::native_to_big_inplace(i.st_uid);
+  boost::endian::native_to_big_inplace(i.st_gid);
+  boost::endian::native_to_big_inplace(i.st_atimespec);
+  boost::endian::native_to_big_inplace(i.st_mtimespec);
+  boost::endian::native_to_big_inplace(i.st_ctimespec);
+  boost::endian::native_to_big_inplace(i.st_birthtimespec);
+  boost::endian::native_to_big_inplace(i.st_size);
+  boost::endian::native_to_big_inplace(i.st_blocks);
+  boost::endian::native_to_big_inplace(i.st_blksize);
+  boost::endian::native_to_big_inplace(i.st_flags);
+
+  encode_top(&i, sizeof(i), true);
+}
+
+void packet::encode_top(remote::statfs i, bool should_reserve) {
+  boost::endian::native_to_big_inplace(i.f_bavail);
+  boost::endian::native_to_big_inplace(i.f_bfree);
+  boost::endian::native_to_big_inplace(i.f_blocks);
+  boost::endian::native_to_big_inplace(i.f_favail);
+  boost::endian::native_to_big_inplace(i.f_ffree);
+  boost::endian::native_to_big_inplace(i.f_files);
+
+  encode_top(&i, sizeof(remote::statfs), should_reserve);
+}
+
+void packet::encode_top(remote::statfs_x i) {
+  buffer_.reserve(buffer_.size() + sizeof(remote::statfs) + 1024);
+  encode_top(&i.f_mntfromname[0], 1024, false);
+  encode_top(*dynamic_cast<remote::statfs *>(&i), false);
+}
+
+void packet::encode_top(remote::file_info i) {
+  boost::endian::native_to_big_inplace(i.FileAttributes);
+  boost::endian::native_to_big_inplace(i.ReparseTag);
+  boost::endian::native_to_big_inplace(i.AllocationSize);
+  boost::endian::native_to_big_inplace(i.FileSize);
+  boost::endian::native_to_big_inplace(i.CreationTime);
+  boost::endian::native_to_big_inplace(i.LastAccessTime);
+  boost::endian::native_to_big_inplace(i.LastWriteTime);
+  boost::endian::native_to_big_inplace(i.ChangeTime);
+  boost::endian::native_to_big_inplace(i.IndexNumber);
+  boost::endian::native_to_big_inplace(i.HardLinks);
+  boost::endian::native_to_big_inplace(i.EaSize);
+
+  encode_top(&i, sizeof(i), true);
+}
+
+void packet::encrypt(const std::string &token) {
+  try {
+    std::vector<char> result;
+    utils::encryption::encrypt_data(token, buffer_, result);
+    buffer_ = std::move(result);
+    encode_top(static_cast<std::uint32_t>(buffer_.size()));
+  } catch (const std::exception &e) {
+    event_system::instance().raise<repertory_exception>(__FUNCTION__, e.what());
+  }
+}
+
+void packet::transfer_into(std::vector<char> &buffer) {
+  buffer = std::move(buffer_);
+  buffer_ = std::vector<char>();
+  decode_offset_ = 0;
+}
+
+packet &packet::operator=(const std::vector<char> &buffer) noexcept {
+  if (&buffer_ != &buffer) {
+    buffer_ = buffer;
+    decode_offset_ = 0;
+  }
+
+  return *this;
+}
+
+packet &packet::operator=(std::vector<char> &&buffer) noexcept {
+  if (&buffer_ != &buffer) {
+    buffer_ = std::move(buffer);
+    decode_offset_ = 0;
+  }
+
+  return *this;
+}
+
+packet &packet::operator=(const packet &p) noexcept {
+  if (this != &p) {
+    buffer_ = p.buffer_;
+    decode_offset_ = p.decode_offset_;
+  }
+
+  return *this;
+}
+
+packet &packet::operator=(packet &&p) noexcept {
+  if (this != &p) {
+    buffer_ = std::move(p.buffer_);
+    decode_offset_ = p.decode_offset_;
+  }
+
+  return *this;
+}
+} // namespace repertory

src/comm/packet/packet_client.cpp

@@ -0,0 +1,227 @@
+/*
+  Copyright <2018-2022> <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.
+*/
+#include "comm/packet/packet_client.hpp"
+#include "events/events.hpp"
+#include "types/repertory.hpp"
+#include "utils/timeout.hpp"
+
+namespace repertory {
+// clang-format off
+E_SIMPLE2(packet_client_timeout, error, true, 
+  std::string, event_name, en, E_STRING, 
+  std::string, message, msg, E_STRING
+);
+// clang-format on
+
+packet_client::packet_client(std::string host_name_or_ip, const std::uint8_t &max_connections,
+                             const std::uint16_t &port, const std::uint16_t &receive_timeout,
+                             const std::uint16_t &send_timeout, std::string encryption_token)
+    : io_context_(),
+      host_name_or_ip_(std::move(host_name_or_ip)),
+      max_connections_(max_connections ? max_connections : 20u),
+      port_(port),
+      receive_timeout_(receive_timeout),
+      send_timeout_(send_timeout),
+      encryption_token_(std::move(encryption_token)),
+      unique_id_(utils::create_uuid_string()) {}
+
+packet_client::~packet_client() {
+  allow_connections_ = false;
+  close_all();
+  io_context_.stop();
+}
+
+void packet_client::close(client &client) const {
+  try {
+    boost::system::error_code ec;
+    client.socket.close(ec);
+  } catch (...) {
+  }
+}
+
+void packet_client::close_all() {
+  unique_mutex_lock clients_lock(clients_mutex_);
+  for (auto &c : clients_) {
+    close(*c.get());
+  }
+
+  clients_.clear();
+  unique_id_ = utils::create_uuid_string();
+}
+
+bool packet_client::connect(client &c) {
+  auto ret = false;
+  try {
+    resolve();
+    boost::asio::connect(c.socket, resolve_results_);
+    c.socket.set_option(boost::asio::ip::tcp::no_delay(true));
+    c.socket.set_option(boost::asio::socket_base::linger(false, 0));
+
+    packet response;
+    read_packet(c, response);
+
+    ret = true;
+  } catch (const std::exception &e) {
+    event_system::instance().raise<repertory_exception>(__FUNCTION__, e.what());
+  }
+  return ret;
+}
+
+std::shared_ptr<packet_client::client> packet_client::get_client() {
+  std::shared_ptr<client> ret;
+
+  unique_mutex_lock clients_lock(clients_mutex_);
+  if (allow_connections_) {
+    if (clients_.empty()) {
+      clients_lock.unlock();
+      ret = std::make_shared<client>(io_context_);
+      connect(*ret);
+    } else {
+      ret = clients_[0u];
+      utils::remove_element_from(clients_, ret);
+      clients_lock.unlock();
+    }
+  }
+
+  return ret;
+}
+
+void packet_client::put_client(std::shared_ptr<client> &c) {
+  mutex_lock clientsLock(clients_mutex_);
+  if (clients_.size() < max_connections_) {
+    clients_.emplace_back(c);
+  }
+}
+
+packet::error_type packet_client::read_packet(client &c, packet &response) {
+  std::vector<char> buffer(sizeof(std::uint32_t));
+  const auto read_buffer = [&]() {
+    std::uint32_t offset = 0u;
+    while (offset < buffer.size()) {
+      const auto bytes_read =
+          boost::asio::read(c.socket, boost::asio::buffer(&buffer[offset], buffer.size() - offset));
+      if (bytes_read <= 0) {
+        throw std::runtime_error("Read failed: " + std::to_string(bytes_read));
+      }
+      offset += static_cast<std::uint32_t>(bytes_read);
+    }
+  };
+  read_buffer();
+
+  const auto size = boost::endian::big_to_native(*reinterpret_cast<std::uint32_t *>(&buffer[0u]));
+  buffer.resize(size);
+
+  read_buffer();
+  response = std::move(buffer);
+
+  auto ret = response.decrypt(encryption_token_);
+  if (ret == 0) {
+    ret = response.decode(c.nonce);
+  }
+
+  return ret;
+}
+
+void packet_client::resolve() {
+  if (resolve_results_.empty()) {
+    resolve_results_ =
+        tcp::resolver(io_context_).resolve({host_name_or_ip_, std::to_string(port_)});
+  }
+}
+
+packet::error_type packet_client::send(const std::string &method, std::uint32_t &service_flags) {
+  packet request;
+  return send(method, request, service_flags);
+}
+
+packet::error_type packet_client::send(const std::string &method, packet &request,
+                                       std::uint32_t &service_flags) {
+  packet response;
+  return send(method, request, response, service_flags);
+}
+
+packet::error_type packet_client::send(const std::string &method, packet &request, packet &response,
+                                       std::uint32_t &service_flags) {
+  auto success = false;
+  packet::error_type ret = utils::translate_api_error(api_error::error);
+  request.encode_top(method);
+  request.encode_top(utils::get_thread_id());
+  request.encode_top(unique_id_);
+  request.encode_top(PACKET_SERVICE_FLAGS);
+  request.encode_top(get_repertory_version());
+
+  static const auto max_attempts = 2;
+  for (auto i = 1; allow_connections_ && not success && (i <= max_attempts); i++) {
+    auto c = get_client();
+    if (c) {
+      try {
+        request.encode_top(c->nonce);
+        request.encrypt(encryption_token_);
+
+        timeout request_timeout(
+            [this, method, c]() {
+              event_system::instance().raise<packet_client_timeout>("Request", method);
+              close(*c.get());
+            },
+            std::chrono::seconds(send_timeout_));
+
+        std::uint32_t offset = 0u;
+        while (offset < request.get_size()) {
+          const auto bytes_written = boost::asio::write(
+              c->socket, boost::asio::buffer(&request[offset], request.get_size() - offset));
+          if (bytes_written <= 0) {
+            throw std::runtime_error("Write failed: " + std::to_string(bytes_written));
+          }
+          offset += static_cast<std::uint32_t>(bytes_written);
+        }
+        request_timeout.disable();
+
+        timeout response_timeout(
+            [this, method, c]() {
+              event_system::instance().raise<packet_client_timeout>("Response", method);
+              close(*c.get());
+            },
+            std::chrono::seconds(receive_timeout_));
+
+        ret = read_packet(*c, response);
+        response_timeout.disable();
+        if (ret == 0) {
+          response.decode(service_flags);
+          response.decode(ret);
+          success = true;
+          put_client(c);
+        }
+      } catch (const std::exception &e) {
+        event_system::instance().raise<repertory_exception>(__FUNCTION__, e.what());
+        close_all();
+        if (allow_connections_ && (i < max_attempts)) {
+          std::this_thread::sleep_for(1s);
+        }
+      }
+    }
+
+    if (not allow_connections_) {
+      ret = utils::translate_api_error(api_error::error);
+      success = true;
+    }
+  }
+
+  return CONVERT_STATUS_NOT_IMPLEMENTED(ret);
+}
+} // namespace repertory

src/comm/packet/packet_server.cpp

@@ -0,0 +1,225 @@
+/*
+  Copyright <2018-2022> <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.
+*/
+#include "comm/packet/packet_server.hpp"
+#include "events/events.hpp"
+#include "events/event_system.hpp"
+#include "comm/packet/packet.hpp"
+#include "types/repertory.hpp"
+#include "utils/utils.hpp"
+
+namespace repertory {
+packet_server::packet_server(const std::uint16_t &port, std::string token, std::uint8_t pool_size,
+                             closed_callback closed, message_handler_callback message_handler)
+    : encryption_token_(std::move(token)), closed_(closed), message_handler_(message_handler) {
+  initialize(port, pool_size);
+}
+
+packet_server::~packet_server() {
+  event_system::instance().raise<service_shutdown>("packet_server");
+  std::thread([this]() {
+    for (std::size_t i = 0u; i < service_threads_.size(); i++) {
+      io_context_.stop();
+    }
+  }).detach();
+
+  server_thread_->join();
+  server_thread_.reset();
+}
+
+void packet_server::add_client(connection &c, const std::string &client_id) {
+  c.client_id = client_id;
+
+  recur_mutex_lock connection_lock(connection_mutex_);
+  if (connection_lookup_.find(client_id) == connection_lookup_.end()) {
+    connection_lookup_[client_id] = 1u;
+  } else {
+    connection_lookup_[client_id]++;
+  }
+}
+
+void packet_server::initialize(const uint16_t &port, uint8_t pool_size) {
+  pool_size = std::max(uint8_t(1u), pool_size);
+  server_thread_ = std::make_unique<std::thread>([this, port, pool_size]() {
+    tcp::acceptor acceptor(io_context_);
+    try {
+      const auto endpoint = tcp::endpoint(tcp::v4(), port);
+      acceptor.open(endpoint.protocol());
+      acceptor.set_option(socket_base::reuse_address(true));
+      acceptor.bind(endpoint);
+      acceptor.listen();
+    } catch (const std::exception &e) {
+      event_system::instance().raise<repertory_exception>(__FUNCTION__, e.what());
+    }
+    listen_for_connection(acceptor);
+
+    for (std::uint8_t i = 0u; i < pool_size; i++) {
+      service_threads_.emplace_back(std::thread([this]() { io_context_.run(); }));
+    }
+
+    for (auto &th : service_threads_) {
+      th.join();
+    }
+  });
+}
+
+void packet_server::listen_for_connection(tcp::acceptor &acceptor) {
+  auto c = std::make_shared<packet_server::connection>(io_context_, acceptor);
+  acceptor.async_accept(
+      c->socket, boost::bind(&packet_server::on_accept, this, c, boost::asio::placeholders::error));
+}
+
+void packet_server::on_accept(std::shared_ptr<connection> c, boost::system::error_code ec) {
+  listen_for_connection(c->acceptor);
+  if (ec) {
+    event_system::instance().raise<repertory_exception>(__FUNCTION__, ec.message());
+    std::this_thread::sleep_for(1s);
+  } else {
+    c->socket.set_option(boost::asio::ip::tcp::no_delay(true));
+    c->socket.set_option(boost::asio::socket_base::linger(false, 0));
+
+    c->generate_nonce();
+
+    packet response;
+    send_response(c, 0, response);
+  }
+}
+
+void packet_server::read_header(std::shared_ptr<connection> c) {
+  c->buffer.resize(sizeof(std::uint32_t));
+  boost::asio::async_read(c->socket, boost::asio::buffer(&c->buffer[0u], c->buffer.size()),
+                          [this, c](boost::system::error_code ec, std::size_t) {
+                            if (ec) {
+                              remove_client(*c);
+                              event_system::instance().raise<repertory_exception>(__FUNCTION__,
+                                                                                ec.message());
+                            } else {
+                              auto to_read = *reinterpret_cast<std::uint32_t *>(&c->buffer[0u]);
+                              boost::endian::big_to_native_inplace(to_read);
+                              read_packet(c, to_read);
+                            }
+                          });
+}
+
+void packet_server::read_packet(std::shared_ptr<connection> c, const std::uint32_t &data_size) {
+  try {
+    const auto read_buffer = [&]() {
+      std::uint32_t offset = 0u;
+      while (offset < c->buffer.size()) {
+        const auto bytes_read = boost::asio::read(
+            c->socket, boost::asio::buffer(&c->buffer[offset], c->buffer.size() - offset));
+        if (bytes_read <= 0) {
+          throw std::runtime_error("read failed: " + std::to_string(bytes_read));
+        }
+        offset += static_cast<std::uint32_t>(bytes_read);
+      }
+    };
+
+    auto should_send_response = true;
+    auto response = std::make_shared<packet>();
+    c->buffer.resize(data_size);
+    read_buffer();
+
+    packet::error_type ret;
+    auto request = std::make_shared<packet>(c->buffer);
+    if (request->decrypt(encryption_token_) == 0) {
+      std::string nonce;
+      if ((ret = request->decode(nonce)) == 0) {
+        if (nonce != c->nonce) {
+          throw std::runtime_error("invalid nonce");
+        }
+        c->generate_nonce();
+
+        std::string version;
+        if ((ret = request->decode(version)) == 0) {
+          if (utils::compare_version_strings(version, MIN_REMOTE_VERSION) >= 0) {
+            std::uint32_t service_flags = 0u;
+            DECODE_OR_IGNORE(request, service_flags);
+
+            std::string client_id;
+            DECODE_OR_IGNORE(request, client_id);
+
+            std::uint64_t thread_id = 0u;
+            DECODE_OR_IGNORE(request, thread_id);
+
+            std::string method;
+            DECODE_OR_IGNORE(request, method);
+
+            if (ret == 0) {
+              if (c->client_id.empty()) {
+                add_client(*c, client_id);
+              }
+
+              should_send_response = false;
+              message_handler_(service_flags, client_id, thread_id, method, request.get(),
+                               *response,
+                               [this, c, request, response](const packet::error_type &result) {
+                                 this->send_response(c, result, *response);
+                               });
+            }
+          } else {
+            ret = utils::translate_api_error(api_error::incompatible_version);
+          }
+        } else {
+          ret = utils::translate_api_error(api_error::invalid_version);
+        }
+      } else {
+        throw std::runtime_error("invalid nonce");
+      }
+    } else {
+      throw std::runtime_error("decryption failed");
+    }
+    if (should_send_response) {
+      send_response(c, ret, *response);
+    }
+  } catch (const std::exception &e) {
+    remove_client(*c);
+    event_system::instance().raise<repertory_exception>(__FUNCTION__, e.what());
+  }
+}
+
+void packet_server::remove_client(connection &c) {
+  if (not c.client_id.empty()) {
+    recur_mutex_lock connection_lock(connection_mutex_);
+    if (not --connection_lookup_[c.client_id]) {
+      connection_lookup_.erase(c.client_id);
+      closed_(c.client_id);
+    }
+  }
+}
+
+void packet_server::send_response(std::shared_ptr<connection> c, const packet::error_type &result,
+                                  packet &response) {
+  response.encode_top(result);
+  response.encode_top(PACKET_SERVICE_FLAGS);
+  response.encode_top(c->nonce);
+  response.encrypt(encryption_token_);
+  response.transfer_into(c->buffer);
+
+  boost::asio::async_write(c->socket, boost::asio::buffer(c->buffer),
+                           [this, c](boost::system::error_code ec, std::size_t /*length*/) {
+                             if (ec) {
+                               remove_client(*c);
+                               event_system::instance().raise<repertory_exception>(__FUNCTION__,
+                                                                                 ec.message());
+                             } else {
+                               read_header(c);
+                             }
+                           });
+}
+} // namespace repertory