Fixed declaration

.gitmodules

@@ -4,7 +4,7 @@
 	branch = master
 [submodule "shared"]
 	path = shared
-	url = https://git.did.science/WolverinDEV/TeaSpeak-SharedLib.git
+	url = https://git.did.science/TeaSpeak/TeaSpeakLibrary.git
 [submodule "music"]
 	path = music
 	url = https://github.com/TeaSpeak/TeaMusic-Providers.git

CMakeLists.txt

@@ -49,7 +49,7 @@ find_package(TomMath REQUIRED)
 find_package(TomCrypt REQUIRED)
 find_package(Breakpad REQUIRED)
 find_package(Protobuf REQUIRED)
-find_package(Boringssl REQUIRED)
+find_package(Crypto REQUIRED)
 find_package(ThreadPool REQUIRED)
 find_package(CXXTerminal REQUIRED)
 find_package(StringVariable REQUIRED)
@@ -103,4 +103,5 @@ add_definitions(-DINET -DINET6)
 add_subdirectory(shared/)
 add_subdirectory(server/)
 add_subdirectory(license/)
-add_subdirectory(MusicBot/)
+add_subdirectory(MusicBot/)
+add_subdirectory(file/)

MusicBot/src/MusicPlayer.cpp

@@ -30,9 +30,12 @@ void AbstractMusicPlayer::unregisterEventHandler(const std::string& string) {
 }
 
 void AbstractMusicPlayer::fireEvent(MusicEvent event) {
-    std::lock_guard lock(this->eventLock);
-    auto listCopy = this->eventHandlers; //Copy for remove while fire
-    for(const auto& entry : listCopy)
+    decltype(this->eventHandlers) handlers{};
+    {
+        std::lock_guard lock(this->eventLock);
+        handlers = this->eventHandlers; //Copy for remove while fire
+    }
+    for(const auto& entry : handlers)
         entry.second(event);
 }
 
@@ -75,11 +78,16 @@ void manager::loadProviders(const std::string& path) {
     }
 
     deque<fs::path> paths;
-    for(const auto& entry : fs::directory_iterator(dir)){
+    error_code error_code{};
+    for(const auto& entry : fs::directory_iterator(dir, error_code)){
         if(!entry.path().has_extension()) continue;
         if(entry.path().extension().string() == ".so")
             paths.push_back(entry.path());
     }
+    if(error_code) {
+        log::log(log::err, "Failed to scan the target directory (" + dir.string() + "): " + error_code.message());
+        return;
+    }
     std::sort(paths.begin(), paths.end(), [](const fs::path& a, const fs::path& b){ return a.filename().string() < b.filename().string(); });
 
     int index = 0;

file/CMakeLists.txt

@@ -0,0 +1,35 @@
+cmake_minimum_required(VERSION 3.6)
+project(TeaSpeak-Files)
+
+#set(CMAKE_CXX_STANDARD 17)
+#set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+add_library(TeaSpeak-FileServer STATIC
+        local_server/LocalFileProvider.cpp
+        local_server/LocalFileSystem.cpp
+        local_server/LocalFileTransfer.cpp
+        local_server/LocalFileTransferClientWorker.cpp
+        local_server/LocalFileTransferDisk.cpp
+        local_server/LocalFileTransferNetwork.cpp
+        local_server/clnpath.cpp
+)
+
+target_link_libraries(TeaSpeak-FileServer PUBLIC TeaSpeak ${StringVariable_LIBRARIES_STATIC} stdc++fs
+        libevent::core libevent::pthreads
+        DataPipes::core::static
+        openssl::ssl::shared
+        openssl::crypto::shared
+)
+
+target_include_directories(TeaSpeak-FileServer PUBLIC include/)
+
+add_executable(TeaSpeak-FileServerTest test/main.cpp)
+target_link_libraries(TeaSpeak-FileServerTest PUBLIC TeaSpeak-FileServer
+        TeaMusic            #Static (Must be in here, so we link against TeaMusic which uses C++11. That forbids GCC to use the newer glibc version)
+        CXXTerminal::static  #Static
+        stdc++fs
+)
+target_compile_options(TeaSpeak-FileServerTest PUBLIC -static-libgcc -static-libstdc++)
+
+add_executable(FileServer-CLNText local_server/clnpath.cpp)
+target_compile_definitions(FileServer-CLNText PUBLIC -DCLN_EXEC)

file/include/files/FileServer.h

@@ -0,0 +1,307 @@
+#pragma once
+
+#include <string>
+#include <chrono>
+#include <Definitions.h>
+#include <condition_variable>
+#include <variant>
+#include <deque>
+#include <functional>
+
+#define TRANSFER_KEY_LENGTH (32)
+
+namespace ts::server::file {
+    enum struct ExecuteStatus {
+        UNKNOWN,
+        WAITING,
+        SUCCESS,
+        ERROR
+    };
+
+    template<typename VariantType, typename T, std::size_t index = 0>
+    constexpr std::size_t variant_index() {
+        if constexpr (index == std::variant_size_v<VariantType>) {
+            return index;
+        } else if constexpr (std::is_same_v<std::variant_alternative_t<index, VariantType>, T>) {
+            return index;
+        } else {
+            return variant_index<VariantType, T, index + 1>();
+        }
+    }
+
+    struct EmptyExecuteResponse { };
+    template <class error_t, class response_t = EmptyExecuteResponse>
+    class ExecuteResponse {
+            typedef std::variant<EmptyExecuteResponse, error_t, response_t> variant_t;
+        public:
+            ExecuteStatus status{ExecuteStatus::WAITING};
+
+            [[nodiscard]] inline const auto& response() const { return std::get<response_t>(this->response_); }
+
+            template <typename = std::enable_if_t<!std::is_void<error_t>::value>>
+            [[nodiscard]] inline const error_t& error() const { return std::get<error_t>(this->response_); }
+
+            inline void wait() const {
+                std::unique_lock nlock{this->notify_mutex};
+                this->notify_cv.wait(nlock, [&]{ return this->status != ExecuteStatus::WAITING; });
+            }
+
+            template<typename _Rep, typename _Period>
+            [[nodiscard]] inline bool wait_for(const std::chrono::duration<_Rep, _Period>& time) const {
+                std::unique_lock nlock{this->notify_mutex};
+                return this->notify_cv.wait_for(nlock, time, [&]{ return this->status != ExecuteStatus::WAITING; });
+            }
+
+            template <typename... Args>
+            inline void emplace_success(Args&&... args) {
+                constexpr auto success_index = variant_index<variant_t, response_t>();
+
+                std::lock_guard rlock{this->notify_mutex};
+                this->response_.template emplace<success_index, Args...>(std::forward<Args>(args)...);
+                this->status = ExecuteStatus::SUCCESS;
+                this->notify_cv.notify_all();
+            }
+
+            template <typename... Args>
+            inline void emplace_fail(Args&&... args) {
+                constexpr auto error_index = variant_index<variant_t, error_t>();
+
+                std::lock_guard rlock{this->notify_mutex};
+                this->response_.template emplace<error_index, Args...>(std::forward<Args>(args)...);
+                this->status = ExecuteStatus::ERROR;
+                this->notify_cv.notify_all();
+            }
+
+            [[nodiscard]] inline bool succeeded() const {
+                return this->status == ExecuteStatus::SUCCESS;
+            }
+
+            ExecuteResponse(std::mutex& notify_mutex, std::condition_variable& notify_cv)
+                : notify_mutex{notify_mutex}, notify_cv{notify_cv} {}
+        private:
+            variant_t response_{}; /* void* as default value so we don't initialize error_t or response_t */
+
+            std::mutex& notify_mutex;
+            std::condition_variable& notify_cv;
+    };
+
+    namespace filesystem {
+        template <typename ErrorCodes>
+        struct DetailedError {
+            ErrorCodes error_type{ErrorCodes::UNKNOWN};
+            std::string error_message{};
+
+            DetailedError(ErrorCodes type, std::string extraMessage) : error_type{type}, error_message{std::move(extraMessage)} {}
+        };
+
+        enum struct DirectoryQueryErrorType {
+            UNKNOWN,
+            PATH_EXCEEDS_ROOT_PATH,
+            PATH_IS_A_FILE,
+            PATH_DOES_NOT_EXISTS,
+            FAILED_TO_LIST_FILES,
+
+            MAX
+        };
+        constexpr std::array<std::string_view, (int) DirectoryQueryErrorType::MAX> directory_query_error_messages = {
+            "unknown error",
+            "path exceeds base path",
+            "path is a file",
+            "path does not exists",
+            "failed to list files"
+        };
+
+        typedef DetailedError<DirectoryQueryErrorType> DirectoryQueryError;
+
+        struct DirectoryEntry {
+            enum Type {
+                UNKNOWN,
+                DIRECTORY,
+                FILE
+            };
+
+            Type type{Type::UNKNOWN};
+            std::string name{};
+            std::chrono::system_clock::time_point modified_at{};
+
+            size_t size{0};
+        };
+
+        enum struct DirectoryModifyErrorType {
+            UNKNOWN,
+            PATH_EXCEEDS_ROOT_PATH,
+            PATH_ALREADY_EXISTS,
+            FAILED_TO_CREATE_DIRECTORIES
+        };
+        typedef DetailedError<DirectoryModifyErrorType> DirectoryModifyError;
+
+        enum struct FileModifyErrorType {
+            UNKNOWN,
+            PATH_EXCEEDS_ROOT_PATH,
+            TARGET_PATH_EXCEEDS_ROOT_PATH,
+            PATH_DOES_NOT_EXISTS,
+            TARGET_PATH_ALREADY_EXISTS,
+            FAILED_TO_DELETE_FILES,
+            FAILED_TO_RENAME_FILE,
+
+            SOME_FILES_ARE_LOCKED
+        };
+        typedef DetailedError<FileModifyErrorType> FileModifyError;
+
+        enum struct ServerCommandErrorType {
+            UNKNOWN,
+            FAILED_TO_CREATE_DIRECTORIES,
+            FAILED_TO_DELETE_DIRECTORIES
+        };
+        typedef DetailedError<ServerCommandErrorType> ServerCommandError;
+
+        class AbstractProvider {
+            public:
+                typedef ExecuteResponse<DirectoryQueryError, std::deque<DirectoryEntry>> directory_query_response_t;
+
+                /* server */
+                [[nodiscard]] virtual std::shared_ptr<ExecuteResponse<ServerCommandError>> initialize_server(ServerId /* server */) = 0;
+                [[nodiscard]] virtual std::shared_ptr<ExecuteResponse<ServerCommandError>> delete_server(ServerId /* server */) = 0;
+
+                /* channels */
+                [[nodiscard]] virtual std::shared_ptr<directory_query_response_t> query_channel_directory(ServerId /* server */, ChannelId /* channel */, const std::string& /* path */) = 0;
+                [[nodiscard]] virtual std::shared_ptr<ExecuteResponse<DirectoryModifyError>> create_channel_directory(ServerId /* server */, ChannelId /* channel */, const std::string& /* path */) = 0;
+                [[nodiscard]] virtual std::shared_ptr<ExecuteResponse<FileModifyError>> delete_channel_file(ServerId /* server */, ChannelId /* channel */, const std::string& /* path */) = 0;
+                [[nodiscard]] virtual std::shared_ptr<ExecuteResponse<FileModifyError>> rename_channel_file(ServerId /* server */, ChannelId /* channel */, const std::string& /* path */, const std::string& /* target */) = 0;
+
+                /* icons */
+                [[nodiscard]] virtual std::shared_ptr<directory_query_response_t> query_icon_directory(ServerId /* server */) = 0;
+                [[nodiscard]] virtual std::shared_ptr<ExecuteResponse<FileModifyError>> delete_icon(ServerId /* server */, const std::string& /* name */) = 0;
+
+                /* avatars */
+                [[nodiscard]] virtual std::shared_ptr<directory_query_response_t> query_avatar_directory(ServerId /* server */) = 0;
+                [[nodiscard]] virtual std::shared_ptr<ExecuteResponse<FileModifyError>> delete_avatar(ServerId /* server */, const std::string& /* name */) = 0;
+            private:
+        };
+    }
+
+    namespace transfer {
+        typedef uint32_t transfer_id;
+
+        struct Transfer {
+            transfer_id server_transfer_id{0};
+            transfer_id client_transfer_id{0};
+
+            ServerId server_id{0};
+            ClientId client_id{0};
+            ChannelId channel_id{0};
+
+            char transfer_key[TRANSFER_KEY_LENGTH]{};
+            std::chrono::system_clock::time_point initialized_timestamp{};
+            enum Direction {
+                DIRECTION_UNKNOWN,
+                DIRECTION_UPLOAD,
+                DIRECTION_DOWNLOAD
+            } direction{DIRECTION_UNKNOWN};
+
+            struct Address {
+                std::string hostname{};
+                uint16_t port{0};
+            };
+            std::vector<Address> server_addresses{};
+
+            enum TargetType {
+                TARGET_TYPE_UNKNOWN,
+                TARGET_TYPE_CHANNEL_FILE,
+                TARGET_TYPE_ICON,
+                TARGET_TYPE_AVATAR
+            } target_type{TARGET_TYPE_UNKNOWN};
+            std::string target_file_path{};
+
+            int64_t max_bandwidth{-1};
+            size_t expected_file_size{0}; /* incl. the offset! */
+            size_t file_offset{0};
+            bool override_exiting{false};
+        };
+
+        struct TransferStatistics {
+            uint64_t network_bytes_send{0};
+            uint64_t network_bytes_received{0};
+
+            uint64_t delta_network_bytes_send{0};
+            uint64_t delta_network_bytes_received{0};
+
+            uint64_t file_bytes_transferred{0};
+            uint64_t delta_file_bytes_transferred{0};
+
+            size_t file_start_offset{0};
+            size_t file_current_offset{0};
+            size_t file_total_size{0};
+        };
+
+        struct TransferInitError {
+            enum Type {
+                UNKNOWN
+            } error_type{UNKNOWN};
+            std::string error_message{};
+        };
+
+        struct TransferActionError {
+            enum Type {
+                UNKNOWN,
+
+                UNKNOWN_TRANSFER
+            } error_type{UNKNOWN};
+            std::string error_message{};
+        };
+
+        struct TransferError {
+            enum Type {
+                UNKNOWN,
+
+                TRANSFER_TIMEOUT,
+
+                DISK_IO_ERROR,
+                DISK_TIMEOUT,
+                DISK_INITIALIZE_ERROR,
+
+                NETWORK_IO_ERROR,
+
+                UNEXPECTED_CLIENT_DISCONNECT,
+                UNEXPECTED_DISK_EOF
+            } error_type{UNKNOWN};
+            std::string error_message{};
+        };
+
+        class AbstractProvider {
+            public:
+                struct TransferInfo {
+                    std::string file_path{};
+
+                    bool override_exiting{false}; /* only for upload valid */
+                    size_t file_offset{0};
+                    size_t expected_file_size{0};
+                    int64_t max_bandwidth{-1};
+                };
+
+                virtual std::shared_ptr<ExecuteResponse<TransferInitError, std::shared_ptr<Transfer>>> initialize_channel_transfer(Transfer::Direction /* direction */, ServerId /* server */, ChannelId /* channel */, const TransferInfo& /* info */) = 0;
+                virtual std::shared_ptr<ExecuteResponse<TransferInitError, std::shared_ptr<Transfer>>> initialize_icon_transfer(Transfer::Direction /* direction */, ServerId /* server */, const TransferInfo& /* info */) = 0;
+                virtual std::shared_ptr<ExecuteResponse<TransferInitError, std::shared_ptr<Transfer>>> initialize_avatar_transfer(Transfer::Direction /* direction */, ServerId /* server */, const TransferInfo& /* info */) = 0;
+
+                virtual std::shared_ptr<ExecuteResponse<TransferActionError>> stop_transfer(transfer_id /* id */, bool /* flush */) = 0;
+
+                std::function<void(const std::shared_ptr<Transfer>&)> callback_transfer_registered{}; /* transfer has been registered */
+                std::function<void(const std::shared_ptr<Transfer>&)> callback_transfer_started{}; /* transfer has been started */
+                std::function<void(const std::shared_ptr<Transfer>&)> callback_transfer_finished{}; /* transfer has been finished */
+                std::function<void(const std::shared_ptr<Transfer>&, const TransferError&)> callback_transfer_aborted{}; /* an error happened while transferring the data  */
+                std::function<void(const std::shared_ptr<Transfer>&, const TransferStatistics&)> callback_transfer_statistics{};
+        };
+    }
+
+    class AbstractFileServer {
+        public:
+            [[nodiscard]] virtual filesystem::AbstractProvider& file_system() = 0;
+            [[nodiscard]] virtual transfer::AbstractProvider& file_transfer() = 0;
+        private:
+    };
+
+    extern bool initialize(std::string& /* error */);
+    extern void finalize();
+
+    extern std::shared_ptr<AbstractFileServer> server();
+}

file/local_server/LocalFileProvider.cpp

@@ -0,0 +1,121 @@
+//
+// Created by WolverinDEV on 28/04/2020.
+//
+
+#include <netinet/in.h>
+#include "LocalFileProvider.h"
+
+using namespace ts::server;
+using LocalFileServer = file::LocalFileProvider;
+
+EVP_PKEY* ssl_generate_key() {
+    auto key = std::unique_ptr<EVP_PKEY, decltype(&EVP_PKEY_free)>(EVP_PKEY_new(), ::EVP_PKEY_free);
+
+    auto rsa = RSA_new();
+    auto e = std::unique_ptr<BIGNUM, decltype(&BN_free)>(BN_new(), ::BN_free);
+    BN_set_word(e.get(), RSA_F4);
+    if(!RSA_generate_key_ex(rsa, 2048, e.get(), nullptr)) return nullptr;
+    EVP_PKEY_assign_RSA(key.get(), rsa);
+    return key.release();
+}
+
+X509* ssl_generate_certificate(EVP_PKEY* key) {
+    auto cert = X509_new();
+    X509_set_pubkey(cert, key);
+
+    ASN1_INTEGER_set(X509_get_serialNumber(cert), 3);
+    X509_gmtime_adj(X509_get_notBefore(cert), 0);
+    X509_gmtime_adj(X509_get_notAfter(cert), 31536000L);
+
+    X509_NAME* name = nullptr;
+    name = X509_get_subject_name(cert);
+    //for(const auto& subject : this->subjects)
+    //    X509_NAME_add_entry_by_txt(name, subject.first.c_str(),  MBSTRING_ASC, (unsigned char *) subject.second.c_str(), subject.second.length(), -1, 0);
+    X509_set_subject_name(cert, name);
+
+    name = X509_get_issuer_name(cert);
+    //for(const auto& subject : this->issues)
+    //    X509_NAME_add_entry_by_txt(name, subject.first.c_str(),  MBSTRING_ASC, (unsigned char *) subject.second.c_str(), subject.second.length(), -1, 0);
+
+    X509_set_issuer_name(cert, name);
+
+    X509_sign(cert, key, EVP_sha512());
+    return cert;
+}
+
+std::shared_ptr<LocalFileServer> server_instance{};
+bool file::initialize(std::string &error) {
+    server_instance = std::make_shared<LocalFileProvider>();
+
+    auto options = std::make_shared<pipes::SSL::Options>();
+    options->verbose_io = true;
+    options->context_method = SSLv23_method();
+    options->free_unused_keypairs = false;
+
+    {
+        std::shared_ptr<EVP_PKEY> pkey{ssl_generate_key(), ::EVP_PKEY_free};
+        std::shared_ptr<X509> cert{ssl_generate_certificate(&*pkey), ::X509_free};
+
+        options->default_keypair({pkey, cert});
+    }
+
+    if(!server_instance->initialize(error, options)) {
+        server_instance = nullptr;
+        return false;
+    }
+    return true;
+}
+
+void file::finalize() {
+    auto server = std::exchange(server_instance, nullptr);
+    if(!server) return;
+
+    server->finalize();
+}
+
+std::shared_ptr<file::AbstractFileServer> file::server() {
+    return server_instance;
+}
+
+LocalFileServer::LocalFileProvider() : file_system_{}, file_transfer_{this->file_system_} {}
+LocalFileServer::~LocalFileProvider() {}
+
+bool LocalFileServer::initialize(std::string &error, const std::shared_ptr<pipes::SSL::Options>& ssl_options) {
+    if(!this->file_system_.initialize(error, "file-root/"))
+        return false;
+
+
+    std::deque<std::shared_ptr<transfer::NetworkBinding>> bindings{};
+    {
+        auto binding = std::make_shared<transfer::NetworkBinding>();
+
+        binding->hostname = "localhost";
+
+        auto& iaddr = *(sockaddr_in*) &binding->address;
+        iaddr.sin_family = AF_INET;
+        iaddr.sin_port = htons(1112);
+        iaddr.sin_addr.s_addr = INADDR_ANY;
+
+        bindings.push_back(std::move(binding));
+    }
+
+    if(!this->file_transfer_.start(bindings, ssl_options)) {
+        error = "transfer server startup failed";
+        this->file_system_.finalize();
+        return false;
+    }
+    return true;
+}
+
+void LocalFileServer::finalize() {
+    this->file_transfer_.stop();
+    this->file_system_.finalize();
+}
+
+file::filesystem::AbstractProvider &LocalFileServer::file_system() {
+    return this->file_system_;
+}
+
+file::transfer::AbstractProvider & LocalFileServer::file_transfer() {
+    return this->file_transfer_;
+}

file/local_server/LocalFileProvider.h

@@ -0,0 +1,547 @@
+#pragma once
+
+#include <files/FileServer.h>
+#include <deque>
+#include <utility>
+#include <thread>
+#include <shared_mutex>
+#include <sys/socket.h>
+#include <pipes/ws.h>
+#include <pipes/ssl.h>
+#include <misc/net.h>
+#include <random>
+
+#define TRANSFER_MAX_CACHED_BYTES (1024 * 1024 * 1) // Buffer up to 1mb
+
+namespace ts::server::file {
+    namespace filesystem {
+#ifdef FS_INCLUDED
+        namespace fs = std::experimental::filesystem;
+#endif
+
+        class LocalFileSystem : public filesystem::AbstractProvider {
+                using FileModifyError = filesystem::FileModifyError;
+                using DirectoryModifyError = filesystem::DirectoryModifyError;
+            public:
+                enum struct FileCategory {
+                    ICON,
+                    AVATAR,
+                    CHANNEL
+                };
+
+                virtual ~LocalFileSystem();
+
+                bool initialize(std::string & /* error */, const std::string & /* root path */);
+                void finalize();
+
+                void lock_file(const std::string& /* absolute path */);
+                void unlock_file(const std::string& /* absolute path */);
+
+                [[nodiscard]] inline const auto &root_path() const { return this->root_path_; }
+
+                [[nodiscard]] std::string absolute_avatar_path(ServerId, const std::string&);
+                [[nodiscard]] std::string absolute_icon_path(ServerId, const std::string&);
+                [[nodiscard]] std::string absolute_channel_path(ServerId, ChannelId, const std::string&);
+
+                std::shared_ptr<ExecuteResponse<ServerCommandError>> initialize_server(ServerId /* server */) override;
+                std::shared_ptr<ExecuteResponse<ServerCommandError>> delete_server(ServerId /* server */) override;
+
+                std::shared_ptr<directory_query_response_t>
+                query_channel_directory(ServerId id, ChannelId channelId, const std::string &string) override;
+
+                std::shared_ptr<ExecuteResponse<DirectoryModifyError>>
+                create_channel_directory(ServerId id, ChannelId channelId, const std::string &string) override;
+
+                std::shared_ptr<ExecuteResponse<FileModifyError>>
+                delete_channel_file(ServerId id, ChannelId channelId, const std::string &string) override;
+
+                std::shared_ptr<ExecuteResponse<FileModifyError>>
+                rename_channel_file(ServerId id, ChannelId channelId, const std::string &, const std::string &) override;
+
+                std::shared_ptr<directory_query_response_t> query_icon_directory(ServerId id) override;
+
+                std::shared_ptr<ExecuteResponse<FileModifyError>>
+                delete_icon(ServerId id, const std::string &string) override;
+
+                std::shared_ptr<directory_query_response_t> query_avatar_directory(ServerId id) override;
+
+                std::shared_ptr<ExecuteResponse<FileModifyError>>
+                delete_avatar(ServerId id, const std::string &string) override;
+
+            private:
+#ifdef FS_INCLUDED
+                [[nodiscard]] fs::path server_path(ServerId);
+                [[nodiscard]] fs::path server_channel_path(ServerId, ChannelId);
+                [[nodiscard]] static bool exceeds_base_path(const fs::path& /* base */, const fs::path& /* target */);
+                [[nodiscard]] bool is_any_file_locked(const fs::path& /* base */, const std::string& /* path */, std::string& /* file (relative to the base) */);
+
+                [[nodiscard]] std::shared_ptr<ExecuteResponse<FileModifyError>>
+                delete_file(const fs::path& /* base */, const std::string &string);
+
+                [[nodiscard]] std::shared_ptr<directory_query_response_t>
+                query_directory(const fs::path& /* base */, const std::string &string, bool);
+#endif
+
+                template <typename error_t, typename result_t = EmptyExecuteResponse>
+                std::shared_ptr<ExecuteResponse<error_t, result_t>> create_execute_response() {
+                    return std::make_shared<ExecuteResponse<error_t, result_t>>(this->result_notify_mutex, this->result_notify_cv);
+                }
+                std::string target_file_path(FileCategory type, ts::ServerId sid, ts::ChannelId cid, const std::string &path);
+
+                std::mutex result_notify_mutex{};
+                std::condition_variable result_notify_cv{};
+
+                std::string root_path_{};
+
+                std::mutex locked_files_mutex{};
+                std::deque<std::string> locked_files_{};
+        };
+    }
+
+    namespace transfer {
+        class LocalFileTransfer;
+
+        struct Buffer {
+            Buffer* next{nullptr};
+
+            size_t capacity{0};
+            size_t length{0};
+            size_t offset{0};
+
+            char data[1]{};
+        };
+        [[nodiscard]] extern Buffer* allocate_buffer(size_t);
+        extern void free_buffer(Buffer*);
+
+        struct NetworkThrottle {
+            constexpr static auto kThrottleTimespanMs{250};
+            typedef uint8_t span_t;
+
+            ssize_t max_bytes{0};
+
+            span_t current_index{0};
+            size_t bytes_send{0};
+
+            inline bool increase_bytes(size_t bytes) {
+                auto current_ms = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
+                auto current_span = (span_t) (current_ms / kThrottleTimespanMs);
+                if(this->current_index != current_span) {
+                    this->current_index = current_span;
+                    this->bytes_send = bytes;
+                } else {
+                    this->bytes_send += bytes;
+                }
+                return this->max_bytes > 0 && this->bytes_send >= this->max_bytes;
+            }
+
+            inline void set_max_bandwidth(ssize_t bytes_per_second) {
+                if(bytes_per_second <= 0)
+                    this->max_bytes = -1;
+                else
+                    this->max_bytes = bytes_per_second * kThrottleTimespanMs / 1000;
+            }
+
+            [[nodiscard]] inline bool should_throttle(timeval& next_timestamp) {
+                if(this->max_bytes <= 0) return false;
+
+                auto current_ms = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
+                auto current_span = (span_t) (current_ms / kThrottleTimespanMs);
+                if(this->current_index != current_span) return false;
+                if(this->bytes_send < this->max_bytes) return false;
+
+                next_timestamp.tv_usec = (kThrottleTimespanMs - current_ms % kThrottleTimespanMs) * 1000;
+                next_timestamp.tv_sec =  next_timestamp.tv_usec / 1000000;
+                next_timestamp.tv_usec -= next_timestamp.tv_sec * 1000000;
+                return true;
+            }
+
+            [[nodiscard]] inline size_t bytes_left() const {
+                if(this->max_bytes <= 0) return (size_t) -1;
+
+                auto current_ms = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
+                auto current_span = (span_t) (current_ms / kThrottleTimespanMs);
+                if(this->current_index != current_span) return this->max_bytes;
+                if(this->bytes_send < this->max_bytes) return this->max_bytes - this->bytes_send;
+                return 0;
+            }
+
+            [[nodiscard]] inline std::chrono::milliseconds expected_writing_time(size_t bytes) const {
+                if(this->max_bytes <= 0) return std::chrono::milliseconds{0};
+
+                return std::chrono::seconds{bytes / (this->max_bytes * (1000 / kThrottleTimespanMs))};
+            }
+        };
+
+        /* all variables are locked via the state_mutex */
+        struct FileClient : std::enable_shared_from_this<FileClient> {
+            LocalFileTransfer* handle;
+            std::shared_ptr<Transfer> transfer{nullptr};
+
+            std::shared_mutex state_mutex{};
+            enum {
+                STATE_AWAITING_KEY, /* includes SSL/HTTP init */
+                STATE_TRANSFERRING,
+                STATE_DISCONNECTING,
+                STATE_DISCONNECTED
+            } state{STATE_AWAITING_KEY};
+
+            enum NetworkingProtocol {
+                PROTOCOL_UNKNOWN,
+                PROTOCOL_HTTPS,
+                PROTOCOL_TS_V1
+            };
+
+            enum HTTPUploadState {
+                HTTP_AWAITING_HEADER,
+                HTTP_STATE_AWAITING_BOUNDARY,
+                HTTP_STATE_UPLOADING,
+                HTTP_STATE_DOWNLOADING
+            };
+
+            struct {
+                bool file_locked{false};
+                std::string absolute_path{};
+
+                int file_descriptor{0};
+
+                bool currently_processing{false};
+                FileClient* next_client{nullptr};
+            } file{};
+
+            struct {
+                size_t provided_bytes{0};
+                char key[TRANSFER_KEY_LENGTH]{0};
+            } transfer_key{};
+
+            /* will be used for both directions */
+            struct {
+                std::mutex mutex{};
+                size_t bytes{0};
+
+                bool buffering_stopped{false};
+
+                Buffer* buffer_head{nullptr};
+                Buffer** buffer_tail{&buffer_head};
+            } buffer{};
+
+            struct {
+                sockaddr_storage address{};
+                int file_descriptor{0};
+
+                NetworkingProtocol protocol{PROTOCOL_UNKNOWN};
+
+                struct event* event_read{nullptr};
+                struct event* event_write{nullptr};
+                struct event* event_throttle{nullptr};
+
+                bool add_event_write{false}, add_event_read{false};
+
+                std::chrono::system_clock::time_point disconnect_timeout{};
+
+                NetworkThrottle throttle;
+
+                pipes::SSL pipe_ssl{};
+                bool pipe_ssl_init{false};
+                std::unique_ptr<Buffer, decltype(free_buffer)*> http_header_buffer{nullptr, free_buffer};
+                HTTPUploadState http_state{HTTPUploadState::HTTP_AWAITING_HEADER};
+
+                /* Only read the transfer key length at the beginning. We than have the actual limit which will be set via throttle */
+                size_t max_read_buffer_size{TRANSFER_KEY_LENGTH};
+            } networking{};
+
+            struct {
+                size_t network_bytes_send{0};
+                size_t network_bytes_received{0};
+
+                size_t file_bytes_transferred{0};
+
+                /* used for delta statistics */
+                size_t last_network_bytes_send{0};
+                size_t last_network_bytes_received{0};
+
+                /* used for delta statistics */
+                size_t last_file_bytes_transferred{0};
+
+                size_t disk_bytes_read{0};
+                size_t disk_bytes_write{0};
+            } statistics{};
+
+            struct {
+                std::chrono::system_clock::time_point last_write{};
+                std::chrono::system_clock::time_point last_read{};
+
+                std::chrono::system_clock::time_point connected{};
+                std::chrono::system_clock::time_point key_received{};
+                std::chrono::system_clock::time_point disconnecting{};
+            } timings;
+
+            explicit FileClient(LocalFileTransfer* handle) : handle{handle} {}
+            ~FileClient();
+
+            void add_network_write_event(bool /* ignore bandwidth limits */);
+            void add_network_write_event_nolock(bool /* ignore bandwidth limits */);
+
+            /* will check if we've enough space in out read buffer again */
+            void add_network_read_event(bool /* ignore bandwidth limits */);
+
+            bool send_file_bytes(const void* /* buffer */, size_t /* length */);
+            bool enqueue_buffer_bytes(const void* /* buffer */, size_t /* length */);
+
+            [[nodiscard]] inline std::string log_prefix() const { return "[" + net::to_string(this->networking.address) + "]"; }
+        };
+
+        enum struct DiskIOStartResult {
+            SUCCESS,
+            OUT_OF_MEMORY
+        };
+
+        enum struct NetworkingStartResult {
+            SUCCESS,
+            OUT_OF_MEMORY,
+            NO_BINDINGS
+        };
+
+        enum struct ClientWorkerStartResult {
+            SUCCESS
+        };
+
+        enum struct NetworkInitializeResult {
+            SUCCESS,
+            OUT_OF_MEMORY
+        };
+
+        enum struct FileInitializeResult {
+            SUCCESS,
+
+            INVALID_TRANSFER_DIRECTION,
+            OUT_OF_MEMORY,
+
+            PROCESS_FILE_LIMIT_REACHED,
+            SYSTEM_FILE_LIMIT_REACHED,
+
+            FILE_IS_BUSY,
+            FILE_DOES_NOT_EXISTS,
+            FILE_SYSTEM_ERROR,
+            FILE_IS_A_DIRECTORY,
+
+            FILE_TOO_LARGE,
+            DISK_IS_READ_ONLY,
+
+            FILE_SIZE_MISMATCH,
+            FILE_SEEK_FAILED,
+
+            FILE_IS_NOT_ACCESSIBLE,
+
+            MAX
+        };
+
+        constexpr static std::array<std::string_view, (size_t) FileInitializeResult::MAX> kFileInitializeResultMessages{
+                /* SUCCESS */                       "success",
+
+                /* INVALID_TRANSFER_DIRECTION */    "invalid file transfer direction",
+                /* OUT_OF_MEMORY */                 "out of memory",
+
+                /* PROCESS_FILE_LIMIT_REACHED */    "process file limit reached",
+                /* SYSTEM_FILE_LIMIT_REACHED */     "system file limit reached",
+
+                /* FILE_IS_BUSY */                  "target file is busy",
+                /* FILE_DOES_NOT_EXISTS */          "target file does not exists",
+                /* FILE_SYSTEM_ERROR */             "internal file system error",
+                /* FILE_IS_A_DIRECTORY */           "target file is a directory",
+
+                /* FILE_TOO_LARGE */                "file is too large",
+                /* DISK_IS_READ_ONLY */             "disk is in read only mode",
+
+                /* FILE_SIZE_MISMATCH */            "file size mismatch",
+                /* FILE_SEEK_FAILED */              "failed to seek to target file offset",
+
+                /* FILE_IS_NOT_ACCESSIBLE */        "file is not accessible"
+        };
+
+        enum struct TransferKeyApplyResult {
+            SUCCESS,
+            FILE_ERROR,
+            UNKNOWN_KEY,
+
+            INTERNAL_ERROR
+        };
+
+        enum struct TransferUploadRawResult {
+            MORE_DATA_TO_RECEIVE,
+            FINISH,
+
+            /* UNKNOWN ERROR */
+        };
+
+        enum struct TransferUploadHTTPResult {
+            MORE_DATA_TO_RECEIVE,
+            FINISH,
+
+            BOUNDARY_MISSING,
+            BOUNDARY_TOKEN_INVALID,
+            BOUNDARY_INVALID,
+
+            MISSING_CONTENT_TYPE,
+            INVALID_CONTENT_TYPE
+            /* UNKNOWN ERROR */
+        };
+
+        struct NetworkBinding : std::enable_shared_from_this<NetworkBinding> {
+            std::string hostname{};
+            sockaddr_storage address{};
+
+            int file_descriptor{-1};
+            struct event* accept_event{nullptr};
+
+            LocalFileTransfer* handle{nullptr};
+        };
+
+        class LocalFileTransfer : public AbstractProvider {
+            public:
+                explicit LocalFileTransfer(filesystem::LocalFileSystem&);
+                ~LocalFileTransfer();
+
+                [[nodiscard]] bool start(const std::deque<std::shared_ptr<NetworkBinding>>& /* bindings */, const std::shared_ptr<pipes::SSL::Options>& /* ssl options */);
+                void stop();
+
+                [[nodiscard]] inline const auto& ssl_options() const {
+                    return this->ssl_options_;
+                }
+
+                inline void set_ssl_options(const std::shared_ptr<pipes::SSL::Options>& options) {
+                    this->ssl_options_ = options;
+                }
+
+                std::shared_ptr<ExecuteResponse<TransferInitError, std::shared_ptr<Transfer>>>
+                initialize_channel_transfer(Transfer::Direction direction, ServerId id, ChannelId channelId,
+                                            const TransferInfo &info) override;
+
+                std::shared_ptr<ExecuteResponse<TransferInitError, std::shared_ptr<Transfer>>>
+                initialize_icon_transfer(Transfer::Direction direction, ServerId id, const TransferInfo &info) override;
+
+                std::shared_ptr<ExecuteResponse<TransferInitError, std::shared_ptr<Transfer>>>
+                initialize_avatar_transfer(Transfer::Direction direction, ServerId id, const TransferInfo &info) override;
+
+                std::shared_ptr<ExecuteResponse<TransferActionError>> stop_transfer(transfer_id id, bool) override;
+            private:
+                enum struct DiskIOLoopState {
+                    STOPPED,
+                    RUNNING,
+
+                    STOPPING,
+                    FORCE_STOPPING
+                };
+                filesystem::LocalFileSystem& file_system_;
+
+                std::atomic<transfer_id> current_transfer_id{0};
+                std::mt19937 transfer_random_token_generator{std::random_device{}()};
+
+                std::mutex result_notify_mutex{};
+                std::condition_variable result_notify_cv{};
+
+                std::mutex transfers_mutex{};
+                std::deque<std::shared_ptr<FileClient>> transfers_{};
+                std::deque<std::shared_ptr<Transfer>> pending_transfers{};
+
+                std::shared_ptr<pipes::SSL::Options> ssl_options_{};
+
+                enum ServerState {
+                    STOPPED,
+                    RUNNING
+                } state{ServerState::STOPPED};
+
+                struct {
+                    bool active{false};
+
+                    std::thread dispatch_thread{};
+                    std::mutex mutex{};
+                    std::condition_variable notify_cv{};
+                } disconnect;
+
+                struct {
+                    bool active{false};
+                    std::thread dispatch_thread{};
+                    struct event_base* event_base{nullptr};
+
+                    std::deque<std::shared_ptr<NetworkBinding>> bindings{};
+                } network{};
+
+                struct {
+                    DiskIOLoopState state{DiskIOLoopState::STOPPED};
+                    std::thread dispatch_thread{};
+                    std::mutex queue_lock{};
+                    std::condition_variable notify_work_awaiting{};
+                    std::condition_variable notify_client_processed{};
+
+                    FileClient* queue_head{nullptr};
+                    FileClient** queue_tail{&queue_head};
+                } disk_io{};
+
+                template <typename error_t, typename result_t = EmptyExecuteResponse>
+                std::shared_ptr<ExecuteResponse<error_t, result_t>> create_execute_response() {
+                    return std::make_shared<ExecuteResponse<error_t, result_t>>(this->result_notify_mutex, this->result_notify_cv);
+                }
+
+                std::shared_ptr<ExecuteResponse<TransferInitError, std::shared_ptr<Transfer>>>
+                initialize_transfer(Transfer::Direction, ServerId, ChannelId, Transfer::TargetType, const TransferInfo &info);
+
+                [[nodiscard]] NetworkingStartResult start_networking();
+                [[nodiscard]] DiskIOStartResult start_disk_io();
+                [[nodiscard]] ClientWorkerStartResult start_client_worker();
+
+                void shutdown_networking();
+                void shutdown_disk_io();
+                void shutdown_client_worker();
+
+                void disconnect_client(const std::shared_ptr<FileClient>& /* client */, std::unique_lock<std::shared_mutex>& /* state lock */, bool /* flush */);
+
+                [[nodiscard]] NetworkInitializeResult initialize_networking(const std::shared_ptr<FileClient>& /* client */, int /* file descriptor */);
+                /* might block 'till all IO operations have been succeeded */
+                void finalize_networking(const std::shared_ptr<FileClient>& /* client */, std::unique_lock<std::shared_mutex>& /* state lock */);
+
+                [[nodiscard]] FileInitializeResult initialize_file_io(const std::shared_ptr<FileClient>& /* client */);
+                void finalize_file_io(const std::shared_ptr<FileClient>& /* client */, std::unique_lock<std::shared_mutex>& /* state lock */);
+
+                [[nodiscard]] bool initialize_client_ssl(const std::shared_ptr<FileClient>& /* client */);
+                void finalize_client_ssl(const std::shared_ptr<FileClient>& /* client */);
+
+                void enqueue_disk_io(const std::shared_ptr<FileClient>& /* client */);
+                void execute_disk_io(const std::shared_ptr<FileClient>& /* client */);
+
+                void report_transfer_statistics(const std::shared_ptr<FileClient>& /* client */);
+                [[nodiscard]] TransferUploadRawResult handle_transfer_upload_raw(const std::shared_ptr<FileClient>& /* client */, const char * /* buffer */, size_t /* length */);
+                [[nodiscard]] TransferUploadHTTPResult handle_transfer_upload_http(const std::shared_ptr<FileClient>& /* client */, const char * /* buffer */, size_t /* length */);
+
+                void send_http_response(const std::shared_ptr<FileClient>& /* client */, http::HttpResponse& /* response */);
+
+                static void callback_transfer_network_write(int, short, void*);
+                static void callback_transfer_network_read(int, short, void*);
+                static void callback_transfer_network_throttle(int, short, void*);
+                static void callback_transfer_network_accept(int, short, void*);
+
+                static void dispatch_loop_client_worker(void*);
+                static void dispatch_loop_network(void*);
+                static void dispatch_loop_disk_io(void*);
+
+                size_t handle_transfer_read(const std::shared_ptr<FileClient>& /* client */, const char* /* buffer */, size_t /* bytes */);
+                size_t handle_transfer_read_raw(const std::shared_ptr<FileClient>& /* client */, const char* /* buffer */, size_t /* bytes */);
+                [[nodiscard]] TransferKeyApplyResult handle_transfer_key_provided(const std::shared_ptr<FileClient>& /* client */, std::string& /* error */);
+        };
+    }
+
+    class LocalFileProvider : public AbstractFileServer {
+        public:
+            LocalFileProvider();
+            virtual ~LocalFileProvider();
+
+            [[nodiscard]] bool initialize(std::string& /* error */, const std::shared_ptr<pipes::SSL::Options>& /* ssl options */);
+            void finalize();
+
+            filesystem::AbstractProvider &file_system() override;
+            transfer::AbstractProvider &file_transfer() override;
+
+        private:
+            filesystem::LocalFileSystem file_system_;
+            transfer::LocalFileTransfer file_transfer_;
+    };
+}

file/local_server/LocalFileSystem.cpp

@@ -0,0 +1,350 @@
+//
+// Created by WolverinDEV on 29/04/2020.
+//
+#include <experimental/filesystem>
+#define FS_INCLUDED
+
+#include <log/LogUtils.h>
+#include "LocalFileProvider.h"
+#include "clnpath.h"
+
+using namespace ts::server::file;
+using namespace ts::server::file::filesystem;
+namespace fs = std::experimental::filesystem;
+using directory_query_response_t = AbstractProvider::directory_query_response_t;
+
+LocalFileSystem::~LocalFileSystem() = default;
+
+bool LocalFileSystem::initialize(std::string &error_message, const std::string &root_path_string) {
+    auto root_path = fs::u8path(root_path_string);
+    std::error_code error{};
+
+    if(!fs::exists(root_path, error)) {
+        if(error)
+            logWarning(LOG_FT, "Failed to check root path existence. Assuming it does not exist. ({}/{})", error.value(), error.message());
+        if(!fs::create_directories(root_path, error) || error) {
+            error_message = "Failed to create root file system at " + root_path_string + ": " + std::to_string(error.value()) + "/" + error.message();
+            return false;
+        }
+    }
+
+    auto croot = clnpath(fs::absolute(root_path).string());
+    logMessage(LOG_FT, "Started file system root at {}", croot);
+    this->root_path_ = croot;
+    return true;
+}
+
+void LocalFileSystem::finalize() {}
+
+fs::path LocalFileSystem::server_path(ts::ServerId id) {
+    return fs::u8path(this->root_path_) / fs::u8path("server_" + std::to_string(id));
+}
+
+fs::path LocalFileSystem::server_channel_path(ts::ServerId sid, ts::ChannelId cid) {
+    return this->server_path(sid) / fs::u8path("channel_" + std::to_string(cid));
+}
+
+bool LocalFileSystem::exceeds_base_path(const fs::path &base, const fs::path &target) {
+    auto rel_target = clnpath(target.string());
+    if(rel_target.starts_with("..")) return true;
+
+    auto base_string = clnpath(fs::absolute(base).string());
+    auto target_string = clnpath(fs::absolute(target).string());
+    return !target_string.starts_with(base_string);
+}
+
+bool LocalFileSystem::is_any_file_locked(const fs::path &base, const std::string &path, std::string &locked_file) {
+    auto c_path = clnpath(fs::absolute(base / fs::u8path(path)).string());
+
+    std::lock_guard lock{this->locked_files_mutex};
+    for(const auto& lfile : this->locked_files_) {
+        if(lfile.starts_with(c_path)) {
+            locked_file = lfile.substr(base.string().length());
+            return true;
+        }
+    }
+
+    return false;
+}
+
+std::string LocalFileSystem::target_file_path(FileCategory type, ts::ServerId sid, ts::ChannelId cid, const std::string &path) {
+    fs::path target_path{};
+    switch (type) {
+        case FileCategory::CHANNEL:
+            target_path = this->server_channel_path(sid, cid) / path;
+            break;
+        case FileCategory::ICON:
+            target_path = this->server_path(sid) / "icons" / path;
+            break;
+        case FileCategory::AVATAR:
+            target_path = this->server_path(sid) / "avatars" / path;
+            break;
+    }
+
+    return clnpath(fs::absolute(target_path).string());
+}
+
+std::string LocalFileSystem::absolute_avatar_path(ServerId sid, const std::string &path) {
+    return this->target_file_path(FileCategory::AVATAR, sid, 0, path);
+}
+
+std::string LocalFileSystem::absolute_icon_path(ServerId sid, const std::string &path) {
+    return this->target_file_path(FileCategory::ICON, sid, 0, path);
+}
+
+std::string LocalFileSystem::absolute_channel_path(ServerId sid, ChannelId cid, const std::string &path) {
+    return this->target_file_path(FileCategory::CHANNEL, sid, cid, path);
+}
+
+void LocalFileSystem::lock_file(const std::string &c_path) {
+    std::lock_guard lock{this->locked_files_mutex};
+    this->locked_files_.push_back(c_path);
+}
+
+void LocalFileSystem::unlock_file(const std::string &c_path) {
+    std::lock_guard lock{this->locked_files_mutex};
+
+    this->locked_files_.erase(std::remove_if(this->locked_files_.begin(), this->locked_files_.end(), [&](const auto& p) { return p == c_path; }), this->locked_files_.end());
+}
+
+std::shared_ptr<ExecuteResponse<ServerCommandError>> LocalFileSystem::initialize_server(ServerId id) {
+    auto path = this->server_path(id);
+    std::error_code error{};
+
+    auto response = this->create_execute_response<ServerCommandError>();
+
+    if(!fs::exists(path, error)) {
+        if(!fs::create_directories(path, error) || error) {
+            response->emplace_fail(ServerCommandErrorType::FAILED_TO_CREATE_DIRECTORIES, std::to_string(error.value()) + "/" + error.message());
+            return response;
+        }
+    }
+
+    //TODO: Copy the default icon
+
+    response->emplace_success();
+    return response;
+}
+
+std::shared_ptr<ExecuteResponse<ServerCommandError>> LocalFileSystem::delete_server(ServerId id) {
+    auto path = this->server_path(id);
+    std::error_code error{};
+
+    auto response = this->create_execute_response<ServerCommandError>();
+
+    //TODO: Stop all running file transfers!
+
+    if(fs::exists(path, error)) {
+        if(!fs::remove_all(path, error) || error) {
+            response->emplace_fail(ServerCommandErrorType::FAILED_TO_DELETE_DIRECTORIES, std::to_string(error.value()) + "/" + error.message());
+            return response;
+        }
+    }
+
+    response->emplace_success();
+    return response;
+}
+
+std::shared_ptr<directory_query_response_t> LocalFileSystem::query_directory(const fs::path &base,
+                                                                             const std::string &path,
+                                                                             bool allow_non_existance) {
+    std::error_code error{};
+    auto response = this->create_execute_response<DirectoryQueryError, std::deque<DirectoryEntry>>();
+    auto target_path = base / fs::u8path(path);
+    if(this->exceeds_base_path(base, target_path)) {
+        response->emplace_fail(DirectoryQueryErrorType::PATH_EXCEEDS_ROOT_PATH, "");
+        return response;
+    }
+
+    if(!fs::exists(target_path, error)) {
+        if(allow_non_existance)
+            response->emplace_success();
+        else
+            response->emplace_fail(DirectoryQueryErrorType::PATH_DOES_NOT_EXISTS, "");
+        return response;
+    } else if(error) {
+        logWarning(LOG_FT, "Failed to check for file at {}: {}. Assuming it does not exists.", target_path.string(), error.value(), error.message());
+        response->emplace_fail(DirectoryQueryErrorType::PATH_DOES_NOT_EXISTS, "");
+        return response;
+    }
+
+    if(!fs::is_directory(target_path, error)) {
+        response->emplace_fail(DirectoryQueryErrorType::PATH_IS_A_FILE, "");
+        return response;
+    } else if(error) {
+        logWarning(LOG_FT, "Failed to check for directory at {}: {}. Assuming its not a directory.", target_path.string(), error.value(), error.message());
+        response->emplace_fail(DirectoryQueryErrorType::PATH_IS_A_FILE, "");
+        return response;
+    }
+
+    std::deque<DirectoryEntry> entries{};
+    for(auto& entry : fs::directory_iterator(target_path, error)) {
+        auto status = entry.status(error);
+        if(error) {
+            logWarning(LOG_FT, "Failed to query file status for {} ({}/{}). Skipping entry for directory query.", entry.path().string(), error.value(), error.message());
+            continue;
+        }
+
+        if(status.type() == fs::file_type::directory) {
+            auto& dentry = entries.emplace_back();
+            dentry.type = DirectoryEntry::DIRECTORY;
+            dentry.name = entry.path().filename();
+
+            dentry.modified_at = fs::last_write_time(entry.path(), error);
+            if(error)
+                logWarning(LOG_FT, "Failed to query last write time for directory {} ({}/{})", entry.path().string(), error.value(), error.message());
+            dentry.size = 0;
+        } else if(status.type() == fs::file_type::regular) {
+            auto& dentry = entries.emplace_back();
+            dentry.type = DirectoryEntry::FILE;
+            dentry.name = entry.path().filename();
+
+            dentry.modified_at = fs::last_write_time(entry.path(), error);
+            if(error)
+                logWarning(LOG_FT, "Failed to query last write time for file {} ({}/{}).", entry.path().string(), error.value(), error.message());
+            dentry.size = fs::file_size(entry.path(), error);
+            if(error)
+                logWarning(LOG_FT, "Failed to query size for file {} ({}/{}).", entry.path().string(), error.value(), error.message());
+        } else {
+            logWarning(LOG_FT, "Directory query listed an unknown file type for file {} ({}).", entry.path().string(), (int) status.type());
+        }
+    }
+    if(error && entries.empty()) {
+        response->emplace_fail(DirectoryQueryErrorType::FAILED_TO_LIST_FILES, std::to_string(error.value()) + "/" + error.message());
+        return response;
+    }
+    response->emplace_success(std::forward<decltype(entries)>(entries));
+    return response;
+}
+
+std::shared_ptr<directory_query_response_t> LocalFileSystem::query_icon_directory(ServerId id) {
+    return this->query_directory(this->server_path(id) / fs::u8path("icons"), "/", true);
+}
+
+std::shared_ptr<directory_query_response_t> LocalFileSystem::query_avatar_directory(ServerId id) {
+    return this->query_directory(this->server_path(id) / fs::u8path("avatars"), "/", true);
+}
+
+std::shared_ptr<directory_query_response_t> LocalFileSystem::query_channel_directory(ServerId id, ChannelId channelId, const std::string &path) {
+    return this->query_directory(this->server_channel_path(id, channelId), path, false);
+}
+
+std::shared_ptr<ExecuteResponse<DirectoryModifyError>> LocalFileSystem::create_channel_directory(ServerId id, ChannelId channelId, const std::string &path) {
+    auto channel_path_root = this->server_channel_path(id, channelId);
+    std::error_code error{};
+
+    auto response = this->create_execute_response<DirectoryModifyError>();
+    auto target_path = channel_path_root / fs::u8path(path);
+    if(this->exceeds_base_path(channel_path_root, target_path)) {
+        response->emplace_fail(DirectoryModifyErrorType::PATH_EXCEEDS_ROOT_PATH, "");
+        return response;
+    }
+
+    if(fs::exists(target_path, error)) {
+        response->emplace_fail(DirectoryModifyErrorType::PATH_ALREADY_EXISTS, "");
+        return response;
+    } else if(error) {
+        logWarning(LOG_FT, "Failed to check for file at {}: {}. Assuming it does not exists.", target_path.string(), error.value(), error.message());
+    }
+
+    if(!fs::create_directories(target_path, error) || error) {
+        response->emplace_fail(DirectoryModifyErrorType::FAILED_TO_CREATE_DIRECTORIES, std::to_string(error.value()) + "/" + error.message());
+        return response;
+    }
+
+    response->emplace_success();
+    return response;
+}
+
+std::shared_ptr<ExecuteResponse<FileModifyError>> LocalFileSystem::rename_channel_file(ServerId id, ChannelId channelId, const std::string &current_path_string, const std::string &new_path_string) {
+    auto channel_path_root = this->server_channel_path(id, channelId);
+    std::error_code error{};
+    std::string locked_file{};
+
+    auto response = this->create_execute_response<FileModifyError>();
+    auto current_path = channel_path_root / fs::u8path(current_path_string);
+    auto target_path = channel_path_root / fs::u8path(new_path_string);
+
+    if(this->exceeds_base_path(channel_path_root, current_path)) {
+        response->emplace_fail(FileModifyErrorType::PATH_EXCEEDS_ROOT_PATH, "");
+        return response;
+    }
+    if(this->exceeds_base_path(channel_path_root, target_path)) {
+        response->emplace_fail(FileModifyErrorType::TARGET_PATH_EXCEEDS_ROOT_PATH, "");
+        return response;
+    }
+
+    if(!fs::exists(current_path, error)) {
+        response->emplace_fail(FileModifyErrorType::PATH_DOES_NOT_EXISTS, "");
+        return response;
+    } else if(error) {
+        logWarning(LOG_FT, "Failed to check for file at {}: {}. Assuming it does not exists.", current_path.string(), error.value(), error.message());
+        response->emplace_fail(FileModifyErrorType::PATH_DOES_NOT_EXISTS, "");
+        return response;
+    }
+
+    if(fs::exists(target_path, error)) {
+        response->emplace_fail(FileModifyErrorType::TARGET_PATH_ALREADY_EXISTS, "");
+        return response;
+    } else if(error) {
+        logWarning(LOG_FT, "Failed to check for file at {}: {}. Assuming it does exists.", current_path.string(), error.value(), error.message());
+        response->emplace_fail(FileModifyErrorType::TARGET_PATH_ALREADY_EXISTS, "");
+        return response;
+    }
+
+    if(this->is_any_file_locked(channel_path_root, current_path, locked_file)) {
+        response->emplace_fail(FileModifyErrorType::SOME_FILES_ARE_LOCKED, locked_file);
+        return response;
+    }
+
+    fs::rename(current_path, target_path, error);
+    if(error) {
+        response->emplace_fail(FileModifyErrorType::FAILED_TO_RENAME_FILE, std::to_string(error.value()) + "/" + error.message());
+        return response;
+    }
+
+    response->emplace_success();
+    return response;
+}
+
+std::shared_ptr<ExecuteResponse<FileModifyError>> LocalFileSystem::delete_file(const fs::path &base,
+                                                                               const std::string &path) {
+    std::error_code error{};
+    std::string locked_file{};
+    auto response = this->create_execute_response<FileModifyError>();
+    auto target_path = base / fs::u8path(path);
+
+    if(fs::exists(target_path, error)) {
+        response->emplace_fail(FileModifyErrorType::TARGET_PATH_ALREADY_EXISTS, "");
+        return response;
+    } else if(error) {
+        logWarning(LOG_FT, "Failed to check for file at {}: {}. Assuming it does exists.", target_path.string(), error.value(), error.message());
+        response->emplace_fail(FileModifyErrorType::TARGET_PATH_ALREADY_EXISTS, "");
+        return response;
+    }
+
+    if(this->is_any_file_locked(base, path, locked_file)) {
+        response->emplace_fail(FileModifyErrorType::SOME_FILES_ARE_LOCKED, locked_file);
+        return response;
+    }
+
+    if(!fs::remove(target_path, error) || error) {
+        response->emplace_fail(FileModifyErrorType::FAILED_TO_DELETE_FILES, std::to_string(error.value()) + "/" + error.message());
+        return response;
+    }
+
+    response->emplace_success();
+    return response;
+}
+
+std::shared_ptr<ExecuteResponse<FileModifyError>> LocalFileSystem::delete_channel_file(ServerId id, ChannelId channelId, const std::string &path) {
+    return this->delete_file(this->server_channel_path(id, channelId), path);
+}
+
+std::shared_ptr<ExecuteResponse<FileModifyError>> LocalFileSystem::delete_icon(ServerId id, const std::string &icon) {
+    return this->delete_file(this->server_path(id) / fs::u8path("icons"), icon);
+}
+
+std::shared_ptr<ExecuteResponse<FileModifyError>> LocalFileSystem::delete_avatar(ServerId id, const std::string &avatar) {
+    return this->delete_file(this->server_path(id) / fs::u8path("avatars"), avatar);
+}

file/local_server/LocalFileTransfer.cpp

@@ -0,0 +1,212 @@
+//
+// Created by WolverinDEV on 04/05/2020.
+//
+
+#include <cassert>
+#include <event2/event.h>
+#include <log/LogUtils.h>
+#include <random>
+#include "./LocalFileProvider.h"
+#include "LocalFileProvider.h"
+
+using namespace ts::server::file;
+using namespace ts::server::file::transfer;
+
+Buffer* transfer::allocate_buffer(size_t size) {
+    auto total_size = sizeof(Buffer) + size;
+    auto buffer = (Buffer*) malloc(total_size);
+    new (buffer) Buffer{};
+    buffer->capacity = size;
+    return buffer;
+}
+
+void transfer::free_buffer(Buffer* buffer) {
+    buffer->~Buffer();
+    free(buffer);
+}
+
+FileClient::~FileClient() {
+    auto head = this->buffer.buffer_head;
+    while (head) {
+        auto next = head->next;
+        free_buffer(head);
+        head = next;
+    }
+
+    assert(!this->file.file_descriptor);
+    assert(!this->file.currently_processing);
+    assert(!this->file.next_client);
+
+    assert(!this->networking.event_read);
+    assert(!this->networking.event_write);
+
+    assert(this->state == STATE_DISCONNECTED);
+}
+
+LocalFileTransfer::LocalFileTransfer(filesystem::LocalFileSystem &fs) : file_system_{fs} {}
+LocalFileTransfer::~LocalFileTransfer() = default;
+
+bool LocalFileTransfer::start(const std::deque<std::shared_ptr<NetworkBinding>>& bindings, const std::shared_ptr<pipes::SSL::Options>& ssl_options) {
+    assert(ssl_options);
+    this->ssl_options_ = ssl_options;
+
+    (void) this->start_client_worker();
+
+    {
+        auto start_result = this->start_disk_io();
+        switch (start_result) {
+            case DiskIOStartResult::SUCCESS:
+                break;
+            case DiskIOStartResult::OUT_OF_MEMORY:
+                logError(LOG_FT, "Failed to start disk worker (Out of memory)");
+                goto error_exit_disk;
+            default:
+                logError(LOG_FT, "Failed to start disk worker ({})", (int) start_result);
+                goto error_exit_disk;
+        }
+    }
+
+
+    {
+        this->network.bindings = bindings;
+        auto start_result = this->start_networking();
+        switch (start_result) {
+            case NetworkingStartResult::SUCCESS:
+                break;
+            case NetworkingStartResult::OUT_OF_MEMORY:
+                logError(LOG_FT, "Failed to start networking (Out of memory)");
+                goto error_exit_network;
+            case NetworkingStartResult::NO_BINDINGS:
+                logError(LOG_FT, "Failed to start networking (No address could be bound)");
+                goto error_exit_network;
+            default:
+                logError(LOG_FT, "Failed to start networking ({})", (int) start_result);
+                goto error_exit_network;
+        }
+    }
+
+    return true;
+    error_exit_network:
+    this->shutdown_networking();
+
+    error_exit_disk:
+    this->shutdown_disk_io();
+    this->shutdown_client_worker();
+    return false;
+}
+
+void LocalFileTransfer::stop() {
+    this->shutdown_networking();
+    this->shutdown_disk_io();
+    this->shutdown_client_worker();
+}
+
+std::shared_ptr<ExecuteResponse<TransferInitError, std::shared_ptr<Transfer>>> LocalFileTransfer::initialize_icon_transfer(Transfer::Direction direction, ServerId sid, const TransferInfo &info) {
+    return this->initialize_transfer(direction, sid, 0, Transfer::TARGET_TYPE_ICON, info);
+}
+
+std::shared_ptr<ExecuteResponse<TransferInitError, std::shared_ptr<Transfer>>> LocalFileTransfer::initialize_avatar_transfer(Transfer::Direction direction, ServerId sid, const TransferInfo &info) {
+    return this->initialize_transfer(direction, sid, 0, Transfer::TARGET_TYPE_AVATAR, info);
+}
+
+std::shared_ptr<ExecuteResponse<TransferInitError, std::shared_ptr<Transfer>>> LocalFileTransfer::initialize_channel_transfer(Transfer::Direction direction, ServerId sid, ChannelId cid, const TransferInfo &info) {
+    return this->initialize_transfer(direction, sid, cid, Transfer::TARGET_TYPE_CHANNEL_FILE, info);
+}
+
+std::shared_ptr<ExecuteResponse<TransferInitError, std::shared_ptr<Transfer>>> LocalFileTransfer::initialize_transfer(
+        Transfer::Direction direction, ServerId sid, ChannelId cid,
+        Transfer::TargetType ttype,
+        const TransferInfo &info) {
+    auto response = this->create_execute_response<TransferInitError, std::shared_ptr<Transfer>>();
+
+    /* TODO: test for a transfer limit */
+
+    auto transfer = std::make_shared<Transfer>();
+    transfer->server_transfer_id = ++this->current_transfer_id;
+    transfer->server_id = sid;
+    transfer->channel_id = cid;
+    transfer->target_type = ttype;
+    transfer->direction = direction;
+
+    transfer->client_id = 0; /* must be provided externally */
+    transfer->client_transfer_id = 0; /* must be provided externally */
+
+    transfer->server_addresses.reserve(this->network.bindings.size());
+    for(auto& binding : this->network.bindings) {
+        if(!binding->file_descriptor) continue;
+
+        transfer->server_addresses.emplace_back(Transfer::Address{binding->hostname, net::port(binding->address)});
+    }
+
+    transfer->target_file_path = info.file_path;
+    transfer->file_offset = info.file_offset;
+    transfer->expected_file_size = info.expected_file_size;
+    transfer->max_bandwidth = info.max_bandwidth;
+
+    constexpr static std::string_view kTokenCharacters{"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"};
+    for(auto& c : transfer->transfer_key)
+        c = kTokenCharacters[transfer_random_token_generator() % kTokenCharacters.length()];
+    transfer->transfer_key[0] = (char) 'r'; /* (114) */ /* a non valid SSL header type to indicate that we're using a file transfer key and not doing a SSL handshake */
+    transfer->transfer_key[1] = (char) 'a'; /* ( 97) */
+    transfer->transfer_key[2] = (char) 'w'; /* (119) */
+
+    transfer->initialized_timestamp = std::chrono::system_clock::now();
+
+    {
+        std::lock_guard tlock{this->transfers_mutex};
+        this->pending_transfers.push_back(transfer);
+    }
+
+    if(auto callback{this->callback_transfer_registered}; callback)
+        callback(transfer);
+
+    response->emplace_success(std::move(transfer));
+    return response;
+}
+
+std::shared_ptr<ExecuteResponse<TransferActionError>> LocalFileTransfer::stop_transfer(transfer_id id, bool flush) {
+    auto response = this->create_execute_response<TransferActionError>();
+
+    std::shared_ptr<Transfer> transfer{};
+    std::shared_ptr<FileClient> connected_transfer{};
+
+    {
+        std::lock_guard tlock{this->transfers_mutex};
+
+        auto ct_it = std::find_if(this->transfers_.begin(), this->transfers_.end(), [&](const std::shared_ptr<FileClient>& t) {
+            return t->transfer && t->transfer->server_transfer_id == id;
+        });
+        if(ct_it != this->transfers_.end())
+            connected_transfer = *ct_it;
+        else {
+            auto t_it = std::find_if(this->pending_transfers.begin(), this->pending_transfers.end(), [&](const std::shared_ptr<Transfer>& t) {
+                return t->server_transfer_id == id;
+            });
+            if(t_it != this->pending_transfers.end()) {
+                transfer = *t_it;
+                this->pending_transfers.erase(t_it);
+            }
+        }
+    }
+
+    if(!transfer) {
+        if(connected_transfer)
+            transfer = connected_transfer->transfer;
+        else {
+            response->emplace_fail(TransferActionError{TransferActionError::UNKNOWN_TRANSFER, ""});
+            return response;
+        }
+    }
+
+    if(connected_transfer) {
+        logMessage(LOG_FT, "{} Stopping transfer due to an user request.", connected_transfer->log_prefix());
+
+        std::unique_lock slock{connected_transfer->state_mutex};
+        this->disconnect_client(connected_transfer, slock, flush);
+    } else {
+        logMessage(LOG_FT, "Removing pending file transfer for id {}", id);
+    }
+
+    response->emplace_success();
+    return response;
+}

file/local_server/LocalFileTransferClientWorker.cpp

@@ -0,0 +1,222 @@
+//
+// Created by WolverinDEV on 04/05/2020.
+//
+
+#include <cassert>
+#include <event2/event.h>
+#include <log/LogUtils.h>
+#include "./LocalFileProvider.h"
+#include "LocalFileProvider.h"
+
+using namespace ts::server::file;
+using namespace ts::server::file::transfer;
+
+ClientWorkerStartResult LocalFileTransfer::start_client_worker() {
+    assert(!this->disconnect.active);
+    this->disconnect.active = true;
+
+    this->disconnect.dispatch_thread = std::thread(&LocalFileTransfer::dispatch_loop_client_worker, this);
+    return ClientWorkerStartResult::SUCCESS;
+}
+
+void LocalFileTransfer::shutdown_client_worker() {
+    if(!this->disconnect.active) return;
+    this->disconnect.active = false;
+
+    this->disconnect.notify_cv.notify_all();
+    if(this->disconnect.dispatch_thread.joinable())
+        this->disconnect.dispatch_thread.join();
+
+    {
+        std::unique_lock tlock{this->transfers_mutex};
+        if(!this->transfers_.empty())
+            logWarning(LOG_FT, "Shutting down disconnect worker even thou we still have some active clients. This could cause memory leaks.");
+    }
+}
+
+void LocalFileTransfer::disconnect_client(const std::shared_ptr<FileClient> &client, std::unique_lock<std::shared_mutex>& state_lock, bool flush) {
+    assert(state_lock.owns_lock());
+
+    if(client->state == FileClient::STATE_DISCONNECTED || (client->state == FileClient::STATE_DISCONNECTING && flush)) {
+        return; /* shall NOT happen */
+    }
+
+#define del_ev_noblock(event) if(event) event_del_noblock(event)
+
+    client->state = flush ? FileClient::STATE_DISCONNECTING : FileClient::STATE_DISCONNECTED;
+    client->timings.disconnecting = std::chrono::system_clock::now();
+    if(flush) {
+        const auto network_flush_time = client->networking.throttle.expected_writing_time(client->buffer.bytes) + std::chrono::seconds{10};
+
+        if(!client->transfer) {
+            del_ev_noblock(client->networking.event_read);
+            del_ev_noblock(client->networking.event_throttle);
+            client->add_network_write_event_nolock(false);
+
+            /* max flush 10 seconds */
+            client->networking.disconnect_timeout = std::chrono::system_clock::now() + network_flush_time;
+            debugMessage(LOG_FT, "{} Disconnecting client. Flushing pending bytes (max {} seconds)", client->log_prefix(), std::chrono::floor<std::chrono::seconds>(network_flush_time).count());
+        } else if(client->transfer->direction == Transfer::DIRECTION_UPLOAD) {
+            del_ev_noblock(client->networking.event_read);
+            del_ev_noblock(client->networking.event_write);
+            del_ev_noblock(client->networking.event_throttle);
+
+            /* no direct timeout needed here, we're just flushing the disk */
+            this->enqueue_disk_io(client);
+        } else if(client->transfer->direction == Transfer::DIRECTION_DOWNLOAD) {
+            del_ev_noblock(client->networking.event_read);
+            client->add_network_write_event_nolock(false);
+
+            /* max flush 10 seconds */
+            client->networking.disconnect_timeout = std::chrono::system_clock::now() + network_flush_time;
+            debugMessage(LOG_FT, "{} Disconnecting client. Flushing pending bytes (max {} seconds)", client->log_prefix(), std::chrono::floor<std::chrono::seconds>(network_flush_time).count());
+        }
+    } else {
+        del_ev_noblock(client->networking.event_read);
+        del_ev_noblock(client->networking.event_write);
+        del_ev_noblock(client->networking.event_throttle);
+
+        this->disconnect.notify_cv.notify_one();
+    }
+
+#undef del_ev_noblock
+}
+
+void LocalFileTransfer::dispatch_loop_client_worker(void *ptr_transfer) {
+    auto provider = reinterpret_cast<LocalFileTransfer*>(ptr_transfer);
+
+    while(provider->disconnect.active) {
+        {
+            std::unique_lock dlock{provider->disconnect.mutex};
+            provider->disconnect.notify_cv.wait_for(dlock, std::chrono::seconds{1});
+        }
+        /* run the disconnect worker at least once before exiting */
+
+        /* transfer statistics */
+        {
+            std::unique_lock tlock{provider->transfers_mutex};
+            auto transfers = provider->transfers_;
+            tlock.unlock();
+            for(const auto& transfer : transfers) {
+                switch(transfer->state) {
+                    case FileClient::STATE_TRANSFERRING:
+                        break;
+                    case FileClient::STATE_DISCONNECTING:
+                        if(transfer->transfer && transfer->transfer->direction == Transfer::DIRECTION_DOWNLOAD)
+                            break; /* we're still transferring (sending data) */
+                    default:
+                        continue;
+                }
+
+                provider->report_transfer_statistics(transfer->shared_from_this());
+            }
+        }
+
+        {
+            std::deque<std::shared_ptr<Transfer>> timeouted_transfers{};
+
+            {
+                std::unique_lock tlock{provider->transfers_mutex};
+
+                auto now = std::chrono::system_clock::now();
+                std::copy_if(provider->pending_transfers.begin(), provider->pending_transfers.end(), std::back_inserter(timeouted_transfers), [&](const std::shared_ptr<Transfer>& t) {
+                    return t->initialized_timestamp + std::chrono::seconds{100} < now; //FIXME: Decrease to 10 again!
+                });
+                provider->pending_transfers.erase(std::remove_if(provider->pending_transfers.begin(), provider->pending_transfers.end(), [&](const auto& t) {
+                    return std::find(timeouted_transfers.begin(), timeouted_transfers.end(), t) != timeouted_transfers.end();
+                }), provider->pending_transfers.end());
+            }
+
+            for(const auto& pt : timeouted_transfers) {
+                if(auto callback{provider->callback_transfer_aborted}; callback)
+                    callback(pt, { TransferError::TRANSFER_TIMEOUT, "" });
+            }
+
+            if(!timeouted_transfers.empty())
+                logMessage(LOG_FT, "Removed {} pending transfers because no request has been made for them.", timeouted_transfers.size());
+        }
+
+
+        {
+            std::deque<std::shared_ptr<FileClient>> disconnected_clients{};
+            {
+                std::unique_lock tlock{provider->transfers_mutex};
+
+                auto now = std::chrono::system_clock::now();
+                std::copy_if(provider->transfers_.begin(), provider->transfers_.end(), std::back_inserter(disconnected_clients), [&](const std::shared_ptr<FileClient>& t) {
+                    std::shared_lock slock{t->state_mutex};
+                    if(t->state == FileClient::STATE_DISCONNECTED) {
+                        return true;
+                    } else if(t->state == FileClient::STATE_AWAITING_KEY) {
+                        return t->timings.connected + std::chrono::seconds{10} < now;
+                    } else if(t->state == FileClient::STATE_TRANSFERRING) {
+                        assert(t->transfer);
+                        if(t->transfer->direction == Transfer::DIRECTION_UPLOAD) {
+                            return false; //FIXME: Due to debugging reasons
+                            return t->timings.last_read + std::chrono::seconds{5} < now;
+                        } else if(t->transfer->direction == Transfer::DIRECTION_DOWNLOAD) {
+                            return t->timings.last_write + std::chrono::seconds{5} < now;
+                        }
+                    } else if(t->state == FileClient::STATE_DISCONNECTING) {
+                        if(t->networking.disconnect_timeout.time_since_epoch().count() > 0)
+                            return t->networking.disconnect_timeout + std::chrono::seconds{5} < now;
+                        return t->timings.disconnecting + std::chrono::seconds{30} < now;
+                    }
+                    return false;
+                });
+                provider->transfers_.erase(std::remove_if(provider->transfers_.begin(), provider->transfers_.end(), [&](const auto& t) {
+                    return std::find(disconnected_clients.begin(), disconnected_clients.end(), t) != disconnected_clients.end();
+                }), provider->transfers_.end());
+            }
+
+            for(auto& client : disconnected_clients) {
+                switch(client->state) {
+                    case FileClient::STATE_AWAITING_KEY:
+                        logMessage(LOG_FT, "{} Received no key. Dropping client.", client->log_prefix());
+                        break;
+                    case FileClient::STATE_TRANSFERRING:
+                        logMessage(LOG_FT, "{} Networking timeout. Dropping client", client->log_prefix());
+                        if(auto callback{provider->callback_transfer_aborted}; callback)
+                            callback(client->transfer, { TransferError::TRANSFER_TIMEOUT, "" });
+                        break;
+                    case FileClient::STATE_DISCONNECTING:
+                        logMessage(LOG_FT, "{} Failed to flush connection. Dropping client", client->log_prefix());
+                        break;
+                    default:
+                        break;
+                }
+                {
+                    std::unique_lock slock{client->state_mutex};
+                    client->state = FileClient::STATE_DISCONNECTED;
+                    provider->finalize_file_io(client, slock);
+                    provider->finalize_client_ssl(client);
+                    provider->finalize_networking(client, slock);
+                }
+
+                debugMessage(LOG_FT, "{} Destroying transfer.", client->log_prefix());
+            }
+        }
+    }
+}
+
+void LocalFileTransfer::report_transfer_statistics(const std::shared_ptr<FileClient> &client) {
+    auto callback{this->callback_transfer_statistics};
+    if(!callback) return;
+
+    TransferStatistics stats{};
+
+    stats.network_bytes_send = client->statistics.network_bytes_send;
+    stats.network_bytes_received = client->statistics.network_bytes_received;
+    stats.file_bytes_transferred = client->statistics.file_bytes_transferred;
+
+    stats.delta_network_bytes_received = stats.network_bytes_received - std::exchange(client->statistics.last_network_bytes_received, stats.network_bytes_received);
+    stats.delta_network_bytes_send = stats.network_bytes_send - std::exchange(client->statistics.last_network_bytes_send, stats.network_bytes_send);
+
+    stats.delta_file_bytes_transferred = stats.file_bytes_transferred - std::exchange(client->statistics.last_file_bytes_transferred, stats.file_bytes_transferred);
+
+    stats.file_start_offset = client->transfer->file_offset;
+    stats.file_current_offset = client->statistics.file_bytes_transferred + client->transfer->file_offset;
+    stats.file_total_size = client->transfer->expected_file_size;
+
+    callback(client->transfer, stats);
+}

file/local_server/LocalFileTransferDisk.cpp

@@ -0,0 +1,475 @@
+//
+// Created by WolverinDEV on 04/05/2020.
+//
+
+#include <cassert>
+#include <event.h>
+#include <experimental/filesystem>
+#include <log/LogUtils.h>
+#include "./LocalFileProvider.h"
+#include "./duration_utils.h"
+#include "LocalFileProvider.h"
+
+using namespace ts::server::file;
+using namespace ts::server::file::transfer;
+namespace fs = std::experimental::filesystem;
+
+DiskIOStartResult LocalFileTransfer::start_disk_io() {
+    assert(this->disk_io.state == DiskIOLoopState::STOPPED);
+
+    this->disk_io.state = DiskIOLoopState::RUNNING;
+    this->disk_io.dispatch_thread = std::thread(&LocalFileTransfer::dispatch_loop_disk_io, this);
+    return DiskIOStartResult::SUCCESS;
+}
+
+void LocalFileTransfer::shutdown_disk_io() {
+    if(this->disk_io.state == DiskIOLoopState::STOPPED) return;
+
+    this->disk_io.state = DiskIOLoopState::STOPPING;
+    {
+        std::unique_lock qlock{this->disk_io.queue_lock};
+        this->disk_io.notify_work_awaiting.notify_all();
+        while(this->disk_io.queue_head)
+            this->disk_io.notify_client_processed.wait_for(qlock, std::chrono::seconds{10});
+
+        if(this->disk_io.queue_head) {
+            logWarning(0, "Failed to flush disk IO. Force aborting.");
+            this->disk_io.state = DiskIOLoopState::FORCE_STOPPING;
+            this->disk_io.notify_work_awaiting.notify_all();
+            this->disk_io.notify_client_processed.wait(qlock);
+        }
+    }
+
+    if(this->disk_io.dispatch_thread.joinable())
+        this->disk_io.dispatch_thread.join();
+
+    this->disk_io.state = DiskIOLoopState::STOPPED;
+}
+
+void LocalFileTransfer::dispatch_loop_disk_io(void *provider_ptr) {
+    auto provider = reinterpret_cast<LocalFileTransfer*>(provider_ptr);
+
+    std::shared_ptr<FileClient> client{};
+    while(true) {
+        {
+            std::unique_lock qlock{provider->disk_io.queue_lock};
+            if(client) {
+                client->file.currently_processing = false;
+                provider->disk_io.notify_client_processed.notify_all();
+                client = nullptr;
+            }
+
+            provider->disk_io.notify_work_awaiting.wait(qlock, [&]{ return provider->disk_io.state != DiskIOLoopState::RUNNING || provider->disk_io.queue_head != nullptr; });
+
+            if(provider->disk_io.queue_head) {
+                client = provider->disk_io.queue_head->shared_from_this();
+
+                provider->disk_io.queue_head = provider->disk_io.queue_head->file.next_client;
+                if(!provider->disk_io.queue_head)
+                    provider->disk_io.queue_tail = &provider->disk_io.queue_head;
+            }
+
+            if(provider->disk_io.state != DiskIOLoopState::RUNNING) {
+                if(provider->disk_io.state == DiskIOLoopState::STOPPING) {
+                    if(!client)
+                        break;
+                    /* break only if all clients have been flushed */
+                } else {
+                    /* force stopping without any flushing */
+                    auto fclient = &*client;
+                    while(fclient)
+                        fclient = std::exchange(fclient->file.next_client, nullptr);
+
+                    provider->disk_io.queue_head = nullptr;
+                    provider->disk_io.queue_tail = &provider->disk_io.queue_head;
+                    break;
+                }
+            }
+
+            if(!client)
+                continue;
+
+            client->file.currently_processing = true;
+            client->file.next_client = nullptr;
+        }
+
+        provider->execute_disk_io(client);
+    }
+    provider->disk_io.notify_client_processed.notify_all();
+}
+
+FileInitializeResult LocalFileTransfer::initialize_file_io(const std::shared_ptr<FileClient> &transfer) {
+    FileInitializeResult result{FileInitializeResult::SUCCESS};
+    assert(transfer->transfer);
+
+    std::shared_lock slock{transfer->state_mutex};
+    auto& file_data = transfer->file;
+    assert(!file_data.file_descriptor);
+    assert(!file_data.next_client);
+
+    {
+        unsigned int open_flags{0};
+        if(transfer->transfer->direction == Transfer::DIRECTION_DOWNLOAD) {
+            open_flags = O_RDONLY;
+
+            std::error_code fs_error{};
+            if(file_data.absolute_path.empty() || !fs::exists(file_data.absolute_path, fs_error)) {
+                result = FileInitializeResult::FILE_DOES_NOT_EXISTS;
+                goto error_exit;
+            } else if(fs_error) {
+                logWarning(LOG_FT, "{} Failed to check for file existence of {}: {}/{}", transfer->log_prefix(), file_data.absolute_path, fs_error.value(), fs_error.message());
+                result = FileInitializeResult::FILE_SYSTEM_ERROR;
+                goto error_exit;
+            }
+        } else if(transfer->transfer->direction == Transfer::DIRECTION_UPLOAD) {
+            open_flags = (unsigned) O_WRONLY | (unsigned) O_CREAT;
+            if(transfer->transfer->override_exiting)
+                open_flags |= (unsigned) O_TRUNC;
+        } else {
+            return FileInitializeResult::INVALID_TRANSFER_DIRECTION;
+        }
+
+        file_data.file_descriptor = open(file_data.absolute_path.c_str(), (int) open_flags, 0644);
+        if(file_data.file_descriptor <= 0) {
+            const auto errno_ = errno;
+            switch (errno_) {
+                case EACCES:
+                    result = FileInitializeResult::FILE_IS_NOT_ACCESSIBLE;
+                    break;
+                case EDQUOT:
+                    logWarning(LOG_FT, "{} Disk inode limit has been reached. Failed to start file transfer for file {}", transfer->log_prefix(), file_data.absolute_path);
+                    result = FileInitializeResult::FILE_SYSTEM_ERROR;
+                    break;
+                case EISDIR:
+                    result = FileInitializeResult::FILE_IS_A_DIRECTORY;
+                    break;
+                case EMFILE:
+                    result = FileInitializeResult::PROCESS_FILE_LIMIT_REACHED;
+                    break;
+                case ENFILE:
+                    result = FileInitializeResult::SYSTEM_FILE_LIMIT_REACHED;
+                    break;
+                case ETXTBSY:
+                    result = FileInitializeResult::FILE_IS_BUSY;
+                    break;
+                case EROFS:
+                    result = FileInitializeResult::DISK_IS_READ_ONLY;
+                    break;
+                default:
+                    logWarning(LOG_FT, "{} Failed to start file transfer for file {}: {}/{}", transfer->log_prefix(), file_data.absolute_path, errno_, strerror(errno_));
+                    result = FileInitializeResult::FILE_SYSTEM_ERROR;
+                    break;
+            }
+            goto error_exit;
+        }
+    }
+
+    this->file_system_.lock_file(transfer->file.absolute_path);
+    transfer->file.file_locked = true;
+
+    if(transfer->transfer->direction == Transfer::DIRECTION_UPLOAD) {
+        if(ftruncate(file_data.file_descriptor, transfer->transfer->expected_file_size) != 0) {
+            const auto errno_ = errno;
+            switch (errno_) {
+                case EACCES:
+                    logWarning(LOG_FT, "{} File {} got inaccessible on truncating, but not on opening.", transfer->log_prefix(), file_data.absolute_path);
+                    result = FileInitializeResult::FILE_IS_NOT_ACCESSIBLE;
+                    goto error_exit;
+
+                case EFBIG:
+                    result = FileInitializeResult::FILE_TOO_LARGE;
+                    goto error_exit;
+
+                case EIO:
+                    logWarning(LOG_FT, "{} A disk IO error occurred while resizing file {}.", transfer->log_prefix(), file_data.absolute_path);
+                    result = FileInitializeResult::FILE_IS_NOT_ACCESSIBLE;
+                    goto error_exit;
+
+                case EROFS:
+                    logWarning(LOG_FT, "{} Failed to resize file {} because disk is in read only mode.", transfer->log_prefix(), file_data.absolute_path);
+                    result = FileInitializeResult::FILE_IS_NOT_ACCESSIBLE;
+                    goto error_exit;
+                default:
+                    debugMessage(LOG_FT, "{} Failed to truncate file {}: {}/{}. Trying to upload file anyways.", transfer->log_prefix(), file_data.absolute_path, errno_, strerror(errno_));
+            }
+        }
+    } else if(transfer->transfer->direction == Transfer::DIRECTION_DOWNLOAD) {
+        auto file_size = lseek(file_data.file_descriptor, 0, SEEK_END);
+        if(file_size != transfer->transfer->expected_file_size) {
+            logWarning(LOG_FT, "{} Expected target file to be of size {}, but file is actually of size {}", transfer->log_prefix(), transfer->transfer->expected_file_size, file_size);
+            result = FileInitializeResult::FILE_SIZE_MISMATCH;
+            goto error_exit;
+        }
+    }
+    {
+        auto new_pos = lseek(file_data.file_descriptor, transfer->transfer->file_offset, SEEK_SET);
+        if(new_pos < 0) {
+            logWarning(LOG_FT, "{} Failed to seek to target file offset ({}): {}/{}", transfer->log_prefix(), transfer->transfer->file_offset, errno, strerror(errno));
+            result = FileInitializeResult::FILE_SEEK_FAILED;
+            goto error_exit;
+        } else if(new_pos != transfer->transfer->file_offset) {
+            logWarning(LOG_FT, "{} File rw offset mismatch after seek. Expected {} but received {}", transfer->log_prefix(), transfer->transfer->file_offset, new_pos);
+            result = FileInitializeResult::FILE_SEEK_FAILED;
+            goto error_exit;
+        }
+        debugMessage(LOG_FT, "{} Seek to file offset {}. New actual offset is {}", transfer->log_prefix(), transfer->transfer->file_offset, new_pos);
+    }
+
+    return FileInitializeResult::SUCCESS;
+    error_exit:
+    if(std::exchange(transfer->file.file_locked, false))
+        this->file_system_.unlock_file(transfer->file.absolute_path);
+
+    if(file_data.file_descriptor > 0)
+        ::close(file_data.file_descriptor);
+    file_data.file_descriptor = 0;
+
+    return result;
+}
+
+void LocalFileTransfer::finalize_file_io(const std::shared_ptr<FileClient> &transfer,
+                                         std::unique_lock<std::shared_mutex> &state_lock) {
+    assert(state_lock.owns_lock());
+
+    auto& file_data = transfer->file;
+
+    state_lock.unlock();
+    {
+        std::unique_lock dlock{this->disk_io.queue_lock};
+        while(true) {
+            if(file_data.currently_processing) {
+                this->disk_io.notify_client_processed.wait(dlock);
+                continue;
+            }
+
+            if(file_data.next_client) {
+                if(this->disk_io.queue_head == &*transfer) {
+                    this->disk_io.queue_head = file_data.next_client;
+                    if(!this->disk_io.queue_head)
+                        this->disk_io.queue_tail = &this->disk_io.queue_head;
+                } else {
+                    FileClient* head{this->disk_io.queue_head};
+                    while(head->file.next_client != &*transfer) {
+                        assert(head->file.next_client);
+                        head = head->file.next_client;
+                    }
+
+                    head->file.next_client = file_data.next_client;
+                    if(!file_data.next_client)
+                        this->disk_io.queue_tail = &head->file.next_client;
+
+                }
+                file_data.next_client = nullptr;
+            }
+
+            break;
+        }
+    }
+    state_lock.lock();
+
+    if(std::exchange(file_data.file_locked, false))
+        this->file_system_.unlock_file(file_data.absolute_path);
+
+    if(file_data.file_descriptor > 0)
+        ::close(file_data.file_descriptor);
+    file_data.file_descriptor = 0;
+}
+
+void LocalFileTransfer::enqueue_disk_io(const std::shared_ptr<FileClient> &client) {
+    if(!client->file.file_descriptor)
+        return;
+
+    if(!client->transfer)
+        return;
+
+    if(client->transfer->direction == Transfer::DIRECTION_DOWNLOAD) {
+        if(client->state != FileClient::STATE_TRANSFERRING)
+            return;
+
+        if(client->buffer.bytes > TRANSFER_MAX_CACHED_BYTES)
+            return;
+    } else if(client->transfer->direction == Transfer::DIRECTION_UPLOAD) {
+        /* we don't do this check because this might be a flush instruction, where the buffer is actually zero bytes filled */
+        /*
+        if(client->buffer.bytes == 0)
+            return;
+        */
+    }
+
+    std::lock_guard dlock{this->disk_io.queue_lock};
+    if(client->file.next_client || this->disk_io.queue_tail == &client->file.next_client)
+        return;
+
+    *this->disk_io.queue_tail = &*client;
+    this->disk_io.queue_tail = &client->file.next_client;
+
+    this->disk_io.notify_work_awaiting.notify_all();
+}
+
+void LocalFileTransfer::execute_disk_io(const std::shared_ptr<FileClient> &client) {
+    if(!client->transfer) return;
+
+    if(client->transfer->direction == Transfer::DIRECTION_UPLOAD) {
+        Buffer* buffer{nullptr};
+        size_t buffer_left_size{0};
+
+        while(true) {
+            {
+                std::lock_guard block{client->buffer.mutex};
+                buffer = client->buffer.buffer_head;
+                buffer_left_size = client->buffer.bytes;
+            }
+            if(!buffer) {
+                assert(buffer_left_size == 0);
+                break;
+            }
+
+            assert(buffer->offset < buffer->length);
+            auto written = ::write(client->file.file_descriptor, buffer->data + buffer->offset, buffer->length - buffer->offset);
+            if(written <= 0) {
+                if(written == 0) {
+                    /* EOF, how the hell is this event possible?! */
+                    auto offset_written = client->statistics.disk_bytes_write + client->transfer->file_offset;
+                    auto aoffset = lseek(client->file.file_descriptor, 0, SEEK_CUR);
+                    logError(LOG_FT, "{} Received unexpected file write EOF. EOF received at {} but expected {}. Actual file offset: {}. Closing transfer.",
+                            client->log_prefix(), offset_written, client->transfer->expected_file_size, aoffset);
+
+                    this->report_transfer_statistics(client);
+                    if(auto callback{client->handle->callback_transfer_aborted}; callback)
+                        callback(client->transfer, { TransferError::UNEXPECTED_DISK_EOF, strerror(errno) });
+
+                    {
+                        std::unique_lock slock{client->state_mutex};
+                        client->handle->disconnect_client(client, slock, true);
+                    }
+                } else {
+                    if(errno == EAGAIN) {
+                        //TODO: Timeout?
+                        this->enqueue_disk_io(client);
+                        break;
+                    }
+
+                    auto offset_written = client->statistics.disk_bytes_write + client->transfer->file_offset;
+                    auto aoffset = lseek(client->file.file_descriptor, 0, SEEK_CUR);
+                    logError(LOG_FT, "{} Received write to disk IO error. Write pointer is at {} of {}. Actual file offset: {}. Closing transfer.",
+                            client->log_prefix(), offset_written, client->transfer->expected_file_size, aoffset);
+
+                    this->report_transfer_statistics(client);
+                    if(auto callback{client->handle->callback_transfer_aborted}; callback)
+                        callback(client->transfer, { TransferError::DISK_IO_ERROR, strerror(errno) });
+
+                    {
+                        std::unique_lock slock{client->state_mutex};
+                        client->handle->disconnect_client(client, slock, true);
+                    }
+                }
+                return;
+            } else {
+                buffer->offset += written;
+                assert(buffer->offset <= buffer->length);
+                if(buffer->length == buffer->offset) {
+                    {
+                        std::lock_guard block{client->buffer.mutex};
+                        client->buffer.buffer_head = buffer->next;
+                        if(!buffer->next)
+                            client->buffer.buffer_tail = &client->buffer.buffer_head;
+
+                        assert(client->buffer.bytes >= written);
+                        client->buffer.bytes -= written;
+                        buffer_left_size = client->buffer.bytes;
+                        (void) buffer_left_size; /* trick my IDE here a bit */
+                    }
+
+                    free_buffer(buffer);
+                } else {
+                    std::lock_guard block{client->buffer.mutex};
+                    assert(client->buffer.bytes >= written);
+                    client->buffer.bytes -= written;
+                    buffer_left_size = client->buffer.bytes;
+                    (void) buffer_left_size; /* trick my IDE here a bit */
+                }
+
+                client->statistics.disk_bytes_write += written;
+            }
+        }
+
+        if(buffer_left_size > 0)
+            this->enqueue_disk_io(client);
+        else if(client->state == FileClient::STATE_DISCONNECTING) {
+            debugMessage(LOG_FT, "{} Disk IO has been flushed.", client->log_prefix());
+
+            std::unique_lock slock{client->state_mutex};
+            client->handle->disconnect_client(client->shared_from_this(), slock, false);
+        }
+
+        if(client->state == FileClient::STATE_TRANSFERRING && buffer_left_size < TRANSFER_MAX_CACHED_BYTES / 2) {
+            if(client->buffer.buffering_stopped)
+                logMessage(LOG_FT, "{} Starting network read, buffer is capable for reading again.", client->log_prefix());
+            client->add_network_read_event(false);
+        }
+    } else if(client->transfer->direction == Transfer::DIRECTION_DOWNLOAD) {
+        if(client->state == FileClient::STATE_DISCONNECTING) return;
+
+        while(true) {
+            constexpr auto buffer_capacity{4096};
+            char buffer[buffer_capacity];
+
+            auto read = ::read(client->file.file_descriptor, buffer, buffer_capacity);
+            if(read <= 0) {
+                if(read == 0) {
+                    /* EOF */
+                    auto offset_send = client->statistics.disk_bytes_read + client->transfer->file_offset;
+                    if(client->transfer->expected_file_size == offset_send) {
+                        debugMessage(LOG_FT, "{} Finished file reading. Flushing and disconnecting transfer. Reading took {} seconds.",
+                                client->log_prefix(), duration_to_string(std::chrono::system_clock::now() - client->timings.key_received));
+                    } else {
+                        auto aoffset = lseek(client->file.file_descriptor, 0, SEEK_CUR);
+                        logError(LOG_FT, "{} Received unexpected read EOF. EOF received at {} but expected {}. Actual file offset: {}. Disconnecting client.",
+                                client->log_prefix(), offset_send, client->transfer->expected_file_size, aoffset);
+
+                        this->report_transfer_statistics(client);
+                        if(auto callback{client->handle->callback_transfer_aborted}; callback)
+                            callback(client->transfer, { TransferError::UNEXPECTED_DISK_EOF, strerror(errno) });
+                    }
+
+                    {
+                        std::unique_lock slock{client->state_mutex};
+                        client->handle->disconnect_client(client, slock, true);
+                    }
+                } else {
+                    if(errno == EAGAIN) {
+                        this->enqueue_disk_io(client);
+                        return;
+                    }
+
+                    logWarning(LOG_FT, "{} Failed to read from file {} ({}/{}). Aborting transfer.", client->log_prefix(), client->file.absolute_path, errno, strerror(errno));
+
+                    this->report_transfer_statistics(client);
+                    if(auto callback{client->handle->callback_transfer_aborted}; callback)
+                        callback(client->transfer, { TransferError::DISK_IO_ERROR, strerror(errno) });
+
+                    {
+                        std::unique_lock slock{client->state_mutex};
+                        client->handle->disconnect_client(client, slock, true);
+                    }
+                }
+                return;
+            } else {
+                auto buffer_full = client->send_file_bytes(buffer, read);
+                client->statistics.disk_bytes_read += read;
+                client->statistics.file_bytes_transferred += read;
+
+                std::shared_lock slock{client->state_mutex};
+                if(buffer_full) {
+                    logMessage(LOG_FT, "{} Stopping buffering from disk. Buffer full ({}bytes)", client->log_prefix(), client->buffer.bytes);
+                    break;
+                }
+
+                /* we've stuff to write again, yeahr */
+                client->add_network_write_event(false);
+            }
+        }
+    } else {
+        logError(LOG_FT, "{} Disk IO scheduled, but transfer direction is unknown.", client->log_prefix());
+    }
+}

file/local_server/clnpath.cpp

@@ -0,0 +1,283 @@
+//
+// Created by WolverinDEV on 29/04/2020.
+//
+
+#include "clnpath.h"
+#include <cstring>
+
+#define MAX_PATH_ELEMENTS   128  /* Number of levels of directory */
+void ts_clnpath(char *path)
+{
+    char           *src;
+    char           *dst;
+    char            c;
+    int             slash = 0;
+
+    /* Convert multiple adjacent slashes to single slash */
+    src = dst = path;
+    while ((c = *dst++ = *src++) != '\0')
+    {
+        if (c == '/')
+        {
+            slash = 1;
+            while (*src == '/')
+                src++;
+        }
+    }
+
+    if (slash == 0)
+        return;
+
+    /* Remove "./" from "./xxx" but leave "./" alone. */
+    /* Remove "/." from "xxx/." but reduce "/." to "/". */
+    /* Reduce "xxx/./yyy" to "xxx/yyy" */
+    src = dst = (*path == '/') ? path + 1 : path;
+    while (src[0] == '.' && src[1] == '/' && src[2] != '\0')
+        src += 2;
+    while ((c = *dst++ = *src++) != '\0')
+    {
+        if (c == '/' && src[0] == '.' && (src[1] == '\0' || src[1] == '/'))
+        {
+            src++;
+            dst--;
+        }
+    }
+    if (path[0] == '/' && path[1] == '.' &&
+        (path[2] == '\0' || (path[2] == '/' && path[3] == '\0')))
+        path[1] = '\0';
+
+    /* Remove trailing slash, if any.  There is at most one! */
+    /* dst is pointing one beyond terminating null */
+    if ((dst -= 2) > path && *dst == '/')
+        *dst++ = '\0';
+}
+
+bool ts_strequal(const char* a, const char* b) {
+    return strcmp(a, b) == 0;
+}
+
+int ts_tokenise(char* ostring, const char* del, char** result, int max_tokens) {
+    int num_tokens{0};
+
+    char* token, *string, *tofree;
+    tofree = string = strdup(ostring);
+    while ((token = strsep(&string, del)) != nullptr) {
+        result[num_tokens++] = strdup(token);
+        if(num_tokens > max_tokens)
+            break;
+    }
+
+    free(tofree);
+    return num_tokens;
+}
+
+/*
+** clnpath2() is not part of the basic clnpath() function because it can
+** change the meaning of a path name if there are symbolic links on the
+** system.  For example, suppose /usr/tmp is a symbolic link to /var/tmp.
+** If the user supplies /usr/tmp/../abcdef as the directory name, clnpath
+** would transform that to /usr/abcdef, not to /var/abcdef which is what
+** the kernel would interpret it as.
+*/
+void ts_clnpath2(char *path)
+{
+    char *token[MAX_PATH_ELEMENTS], *otoken[MAX_PATH_ELEMENTS];
+    int   ntok, ontok;
+
+    ts_clnpath(path);
+
+    /* Reduce "<name>/.." to "/" */
+    ntok = ontok = ts_tokenise(path, "/", otoken, MAX_PATH_ELEMENTS);
+    memcpy(token, otoken, sizeof(char*) * ntok);
+
+    if (ntok > 1) {
+        for (int i = 0; i < ntok - 1; i++)
+        {
+            if (!ts_strequal(token[i], "..") && ts_strequal(token[i + 1], ".."))
+            {
+                if (*token[i] == '\0')
+                    continue;
+                while (i < ntok - 1)
+                {
+                    token[i] = token[i + 2];
+                    i++;
+                }
+                ntok -= 2;
+                i = -1;     /* Restart enclosing for loop */
+            }
+        }
+    }
+
+    /* Reassemble string */
+    char *dst = path;
+    if (ntok == 0)
+    {
+        *dst++ = '.';
+        *dst = '\0';
+    }
+    else
+    {
+        if (token[0][0] == '\0')
+        {
+            int   i;
+            for (i = 1; i < ntok && ts_strequal(token[i], ".."); i++)
+                ;
+            if (i > 1)
+            {
+                int j;
+                for (j = 1; i < ntok; i++)
+                    token[j++] = token[i];
+                ntok = j;
+            }
+        }
+        if (ntok == 1 && token[0][0] == '\0')
+        {
+            *dst++ = '/';
+            *dst = '\0';
+        }
+        else
+        {
+            for (int i = 0; i < ntok; i++)
+            {
+                char *src = token[i];
+                while ((*dst++ = *src++) != '\0')
+                    ;
+                *(dst - 1) = '/';
+            }
+            *(dst - 1) = '\0';
+        }
+    }
+
+    for(int i{0}; i < ontok; i++)
+        ::free(otoken[i]);
+}
+
+std::string clnpath(const std::string_view& data) {
+    std::string result{data};
+    ts_clnpath2(result.data());
+    auto index = result.find((char) 0);
+    if(index != std::string::npos)
+        result.resize(index);
+    return result;
+}
+
+#ifdef CLN_EXEC
+typedef struct p1_test_case
+{
+    const char *input;
+    const char *output;
+} p1_test_case;
+
+/* This stress tests the cleaning, concentrating on the boundaries. */
+static const p1_test_case p1_tests[] =
+        {
+                { "/",                                  "/",            },
+                { "//",                                 "/",            },
+                { "///",                                "/",            },
+                { "/.",                                 "/",            },
+                { "/./",                                "/",            },
+                { "/./.",                               "/",            },
+                { "/././.profile",                      "/.profile",    },
+                { "./",                                 ".",            },
+                { "./.",                                ".",            },
+                { "././",                               ".",            },
+                { "./././.profile",                     ".profile",     },
+                { "abc/.",                              "abc",          },
+                { "abc/./def",                          "abc/def",      },
+                { "./abc",                              "abc",          },
+
+                { "//abcd///./abcd////",                "/abcd/abcd",                   },
+                { "//abcd///././../defg///ddd//.",      "/abcd/../defg/ddd",            },
+                { "/abcd/./../././defg/./././ddd",      "/abcd/../defg/ddd",            },
+                { "//abcd//././../defg///ddd//.///",    "/abcd/../defg/ddd",            },
+
+                /* Most of these are minimal interest in phase 1 */
+                { "/usr/tmp/clnpath.c",                 "/usr/tmp/clnpath.c",           },
+                { "/usr/tmp/",                          "/usr/tmp",                     },
+                { "/bin/..",                            "/bin/..",                      },
+                { "bin/..",                             "bin/..",                       },
+                { "/bin/.",                             "/bin",                         },
+                { "sub/directory",                      "sub/directory",                },
+                { "sub/directory/file",                 "sub/directory/file",           },
+                { "/part1/part2/../.././../",           "/part1/part2/../../..",        },
+                { "/.././../usr//.//bin/./cc",          "/../../usr/bin/cc",            },
+        };
+
+static void p1_tester(const void *data)
+{
+    const p1_test_case *test = (const p1_test_case *)data;
+    char  buffer[256];
+
+    strcpy(buffer, test->input);
+    ts_clnpath(buffer);
+    if (strcmp(buffer, test->output) == 0)
+        printf("<<%s>> cleans to <<%s>>\n", test->input, buffer);
+    else
+    {
+        fprintf(stderr, "<<%s>> - unexpected output from clnpath()\n", test->input);
+        fprintf(stderr, "Wanted <<%s>>\n", test->output);
+        fprintf(stderr, "Actual <<%s>>\n", buffer);
+    }
+}
+
+typedef struct p2_test_case
+{
+    const char *input;
+    const char *output;
+} p2_test_case;
+
+static const p2_test_case p2_tests[] =
+{
+    { "/abcd/../defg/ddd",              "/defg/ddd"         },
+    { "/bin/..",                        "/"                 },
+    { "bin/..",                         "."                 },
+    { "/usr/bin/..",                    "/usr"              },
+    { "/usr/bin/../..",                 "/"                 },
+    { "usr/bin/../..",                  "."                 },
+    { "../part/of/../the/way",          "../part/the/way"   },
+    { "/../part/of/../the/way",         "/part/the/way"     },
+    { "part1/part2/../../part3",        "part3"             },
+    { "part1/part2/../../../part3",     "../part3"          },
+    { "/part1/part2/../../../part3",    "/part3"            },
+    { "/part1/part2/../../../",         "/"                 },
+    { "/../../usr/bin/cc",              "/usr/bin/cc"       },
+    { "../../usr/bin/cc",               "../../usr/bin/cc"  },
+    { "part1/./part2/../../part3",      "part3"             },
+    { "./part1/part2/../../../part3",   "../part3"          },
+    { "/part1/part2/.././../../part3",  "/part3"            },
+    { "/part1/part2/../.././../",       "/"                 },
+    { "/.././..//./usr///bin/cc/",      "/usr/bin/cc"       },
+    {nullptr, nullptr}
+};
+
+static void p2_tester(const void *data)
+{
+    auto test = (const p2_test_case *)data;
+    char  buffer[256];
+
+    strcpy(buffer, test->input);
+    ts_clnpath2(buffer);
+    if (strcmp(buffer, test->output) == 0)
+        printf("<<%s>> cleans to <<%s>>\n", test->input, buffer);
+    else
+    {
+        fprintf(stderr, "<<%s>> - unexpected output from clnpath2()\n", test->input);
+        fprintf(stderr, "Wanted <<%s>>\n", test->output);
+        fprintf(stderr, "Actual <<%s>>\n", buffer);
+    }
+}
+
+int main() {
+    for(const auto& test : p1_tests) {
+        if(!test.input) break;
+        p1_tester(&test);
+    }
+
+    printf("------------------------------\n");
+    for(const auto& test : p2_tests) {
+        if(!test.input) break;
+        p2_tester(&test);
+    }
+}
+
+#endif

file/local_server/clnpath.h

@@ -0,0 +1,6 @@
+#pragma once
+
+#include <string>
+#include <string_view>
+
+extern std::string clnpath(const std::string_view&);

file/local_server/duration_utils.h

@@ -0,0 +1,35 @@
+#pragma once
+
+template <typename Rep, typename Per>
+inline std::string duration_to_string(std::chrono::duration<Rep, Per> ms) {
+    std::string result{};
+
+    {
+        auto hours = std::chrono::duration_cast<std::chrono::hours>(ms);
+        if(hours.count())
+            result += std::to_string(hours.count()) + " hours ";
+        ms -= hours;
+    }
+    {
+        auto minutes = std::chrono::duration_cast<std::chrono::minutes>(ms);
+        if(minutes.count())
+            result += std::to_string(minutes.count()) + " minutes ";
+        ms -= minutes;
+    }
+    {
+        auto seconds = std::chrono::duration_cast<std::chrono::seconds>(ms);
+        if(seconds.count())
+            result += std::to_string(seconds.count()) + " seconds ";
+        ms -= seconds;
+    }
+    if(result.empty()) {
+        auto milliseconds = std::chrono::duration_cast<std::chrono::milliseconds>(ms);
+        if(milliseconds.count())
+            result = std::to_string(milliseconds.count()) + " milliseconds ";
+    }
+    if(result.empty()) {
+        auto microseconds = std::chrono::duration_cast<std::chrono::microseconds>(ms);
+        result = std::to_string(microseconds.count()) + " microseconds ";
+    }
+    return result.substr(0, result.length() - 1);
+}

file/test/main.cpp

@@ -0,0 +1,181 @@
+//
+// Created by WolverinDEV on 29/04/2020.
+//
+
+#include <files/FileServer.h>
+#include <log/LogUtils.h>
+
+#include <experimental/filesystem>
+#include <local_server/clnpath.h>
+#include <event2/thread.h>
+
+namespace fs = std::experimental::filesystem;
+
+using namespace ts::server;
+
+struct Nothing {};
+
+template <typename ErrorType, typename ResponseType>
+inline void print_fs_response(const std::string& message, const std::shared_ptr<file::ExecuteResponse<file::filesystem::DetailedError<ErrorType>, ResponseType>>& response) {
+    if(response->status == file::ExecuteStatus::ERROR)
+        logError(LOG_FT, "{}: {} => {}", message, (int) response->error().error_type, response->error().error_message);
+    else if(response->status == file::ExecuteStatus::SUCCESS)
+        logMessage(LOG_FT, "{}: success", message);
+    else
+        logWarning(LOG_FT, "Unknown response state ({})!", (int) response->status);
+}
+
+template <typename ErrorType, typename ResponseType>
+inline void print_ft_response(const std::string& message, const std::shared_ptr<file::ExecuteResponse<ErrorType, ResponseType>>& response) {
+    if(response->status == file::ExecuteStatus::ERROR)
+        logError(LOG_FT, "{}: {} => {}", message, (int) response->error().error_type, response->error().error_message);
+    else if(response->status == file::ExecuteStatus::SUCCESS)
+        logMessage(LOG_FT, "{}: success", message);
+    else
+        logWarning(LOG_FT, "Unknown response state ({})!", (int) response->status);
+}
+
+inline void print_query(const std::string& message, const file::filesystem::AbstractProvider::directory_query_response_t& response) {
+    if(response.status == file::ExecuteStatus::ERROR)
+        logError(LOG_FT, "{}: {} => {}", message, (int) response.error().error_type, response.error().error_message);
+    else if(response.status == file::ExecuteStatus::SUCCESS) {
+        const auto& entries = response.response();
+        logMessage(LOG_FT, "{}: Found {} entries", message, entries.size());
+        for(auto& entry : entries) {
+            if(entry.type == file::filesystem::DirectoryEntry::FILE)
+                logMessage(LOG_FT, "  - File {}", entry.name);
+            else if(entry.type == file::filesystem::DirectoryEntry::DIRECTORY)
+                logMessage(LOG_FT, "  - Directory {}", entry.name);
+            else
+                logMessage(LOG_FT, "  - Unknown {}", entry.name);
+            logMessage(LOG_FT, "    Write timestamp: {}", std::chrono::floor<std::chrono::seconds>(entry.modified_at.time_since_epoch()).count());
+            logMessage(LOG_FT, "    Size: {}", entry.size);
+        }
+    } else
+        logWarning(LOG_FT, "{}: Unknown response state ({})!", message, (int) response.status);
+}
+
+int main() {
+    evthread_use_pthreads();
+
+    auto log_config = std::make_shared<logger::LoggerConfig>();
+    log_config->terminalLevel = spdlog::level::trace;
+    logger::setup(log_config);
+
+    std::string error{};
+    if(!file::initialize(error)) {
+        logError(LOG_FT, "Failed to initialize file server: {}", error);
+        return 0;
+    }
+    logMessage(LOG_FT, "File server started");
+    auto instance = file::server();
+
+
+#if 0
+    auto& fs = instance->file_system();
+    {
+        auto response = fs.initialize_server(0);
+        response->wait();
+        print_fs_response("Server init result", response);
+        if(response->status != file::ExecuteStatus::SUCCESS)
+            return 0;
+    }
+
+
+    {
+        auto response = fs.create_channel_directory(0, 2, "/");
+        response->wait();
+        print_fs_response("Channel dir create A", response);
+    }
+
+
+    {
+        auto response = fs.create_channel_directory(0, 2, "/test-folder/");
+        response->wait();
+        print_fs_response("Channel dir create B", response);
+    }
+
+
+    {
+        auto response = fs.create_channel_directory(0, 2, "../test-folder/");
+        response->wait();
+        print_fs_response("Channel dir create C", response);
+    }
+
+
+    {
+        auto response = fs.create_channel_directory(0, 2, "./test-folder/../test-folder-2");
+        response->wait();
+        print_fs_response("Channel dir create D", response);
+    }
+
+    {
+        auto response = fs.query_channel_directory(0, 2, "/");
+        response->wait();
+        print_query("Channel query", *response);
+    }
+
+    {
+        auto response = fs.query_icon_directory(0);
+        response->wait();
+        print_query("Icons", *response);
+    }
+
+    {
+        auto response = fs.query_avatar_directory(0);
+        response->wait();
+        print_query("Avatars", *response);
+    }
+
+    {
+        auto response = fs.rename_channel_file(0, 2, "./test-folder/../test-folder-2", "./test-folder/../test-folder-3");
+        response->wait();
+        print_fs_response("Folder rename A", response);
+    }
+
+    {
+        auto response = fs.rename_channel_file(0, 2, "./test-folder/../test-folder-3", "./test-folder/../test-folder-2");
+        response->wait();
+        print_fs_response("Folder rename B", response);
+    }
+#endif
+
+#if 1
+    auto& ft = instance->file_transfer();
+
+    ft.callback_transfer_finished = [](const std::shared_ptr<file::transfer::Transfer>& transfer) {
+        logMessage(0, "Transfer finished");
+    };
+
+    ft.callback_transfer_started = [](const std::shared_ptr<file::transfer::Transfer>& transfer) {
+        logMessage(0, "Transfer started");
+    };
+
+    ft.callback_transfer_aborted = [](const std::shared_ptr<file::transfer::Transfer>& transfer, const file::transfer::TransferError& error) {
+        logMessage(0, "Transfer aborted ({}/{})", (int) error.error_type, error.error_message);
+    };
+
+    ft.callback_transfer_statistics = [](const std::shared_ptr<file::transfer::Transfer>& transfer, const file::transfer::TransferStatistics& stats) {
+        logMessage(0, "Transfer stats. New file bytes: {}, delta bytes send {}", stats.delta_file_bytes_transferred, stats.delta_network_bytes_send);
+    };
+
+    {
+        auto response = ft.initialize_channel_transfer(file::transfer::Transfer::DIRECTION_UPLOAD, 0, 2, {
+                "test2.txt",
+                false,
+                4,
+                120,
+                32
+        });
+        response->wait();
+        print_ft_response("Download test.txt", response);
+        if(response->succeeded())
+            logMessage(LOG_FT, "Download key: {}", std::string{response->response()->transfer_key, TRANSFER_KEY_LENGTH});
+    }
+#endif
+
+    std::this_thread::sleep_for(std::chrono::seconds{120});
+    //TODO: Test file locking
+    file::finalize();
+    return 0;
+}

file/test/upload-content.bin

@@ -0,0 +1,2 @@
+Hello World
+xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

license/CMakeLists.txt

@@ -29,12 +29,13 @@ target_link_libraries(TeaLicenseHelper PUBLIC
 		TeaSpeak
 		protobuf::libprotobuf
 		libevent::core libevent::pthreads
-		openssl::ssl::shared
-		openssl::crypto::shared
+		# openssl::ssl::shared
+		# openssl::crypto::shared
 
 		${StringVariable_LIBRARIES_STATIC}
 		${ed25519_LIBRARIES_STATIC}
 		stdc++fs
+		rt
 )
 target_include_directories(TeaLicenseHelper PUBLIC shared/include/)
 target_include_directories(TeaLicenseHelper PUBLIC ${CMAKE_CURRENT_BINARY_DIR})
@@ -49,7 +50,7 @@ add_executable(TeaLicenseServer ${LICENCE_SOURCE_FILES}
 		server/StatisticManager.cpp
 		server/UserManager.cpp
 		LicenseServerMain.cpp
-		MySQLLibSSLFix.c
+		# Only for boringssl: MySQLLibSSLFix.c
 )
 
 target_link_libraries(TeaLicenseServer
@@ -61,13 +62,14 @@ target_link_libraries(TeaLicenseServer
 
         mysqlclient
         jsoncpp_lib
-		DataPipes::core::shared
-        openssl::ssl::shared
-        openssl::crypto::shared
+		DataPipes::core::static
+        openssl::ssl::static
+        openssl::crypto::static
 
         pthread
         dl
-        z
+		z
+		rt
 )
 
 #The test license client

license/LicenseServerMain.cpp

@@ -31,6 +31,8 @@ using namespace license;
  * Online clients:   SELECT SUM(`clients`) FROM (SELECT DISTINCT(`ip`), `clients` FROM `history_online` WHERE `timestamp` > (UNIX_TIMESTAMP() - 60 * 60 * 2) * 1000) AS `a`
  * Online bots:      SELECT SUM(`clients`) FROM (SELECT DISTINCT(`ip`), `clients` FROM `history_online` WHERE `timestamp` > (UNIX_TIMESTAMP() - 60 * 60 * 2) * 1000) AS `a`
  * Online VS Server: SELECT SUM(`music`) FROM (SELECT DISTINCT(`ip`), `music` FROM `history_online` WHERE `timestamp` > (UNIX_TIMESTAMP() - 60 * 60 * 2) * 1000) AS `a`
+ *
+ * Empty instances: curl -ik "https://stats.teaspeak.de:27788?type=request&request_type=general" -X GET 2>&1 | grep "data:"
  */
 bool handle_command(string& line);
 
@@ -64,10 +66,21 @@ inline std::shared_ptr<WebCertificate> load_web_certificate() {
 			return nullptr;
 		}
 
-		if(!BIO_mem_contents(&*bio, &mem_ptr, &length)) {
-			logError(0, "Failed to receive memptr to private key");
-			return nullptr;
-		}
+#ifdef CRYPTO_BORINGSSL
+        if(!BIO_mem_contents(&*bio_private_key, &mem_ptr, &length))  {
+            logError(0, "Failed to receive memptr to private key");
+            return nullptr;
+        }
+#else
+        BUF_MEM* memory{nullptr};
+        if(!BIO_get_mem_ptr(&*bio, &memory) || !memory) {
+            logError(0, "Failed to receive memptr to private key");
+            return nullptr;
+        }
+
+        mem_ptr = (uint8_t*) memory->data;
+        length = memory->length;
+#endif
 		key.resize(length);
 		memcpy(key.data(), mem_ptr, length);
 	}
@@ -78,10 +91,21 @@ inline std::shared_ptr<WebCertificate> load_web_certificate() {
 			logError(0, "Failed to export certificate");
 			return nullptr;
 		}
-		if(!BIO_mem_contents(&*bio, &mem_ptr, &length)) {
-			logError(0, "Failed to receive memptr to certificate");
-			return nullptr;
-		}
+#ifdef CRYPTO_BORINGSSL
+        if(!BIO_mem_contents(&*bio_private_key, &mem_ptr, &length)) {
+            logError(0, "Failed to receive memptr to public key");
+            return nullptr;
+        }
+#else
+        BUF_MEM* memory{nullptr};
+        if(!BIO_get_mem_ptr(&*bio, &memory) || !memory) {
+            logError(0, "Failed to receive memptr to public key");
+            return nullptr;
+        }
+
+        mem_ptr = (uint8_t*) memory->data;
+        length = memory->length;
+#endif
 		certificate.resize(length);
 		memcpy(certificate.data(), mem_ptr, length);
 	}

license/server/DatabaseHandler.cpp

@@ -408,6 +408,7 @@ std::shared_ptr<DatabaseHandler::UserHistory> DatabaseHandler::list_statistics_u
 					continue; /* last server request is too old to be counted */
 
 				info->instance_online++;
+                info->instance_empty += second.web_clients_online == 0 && second.clients_online == 0;
 				info->queries_online += second.queries_online;
 				info->bots_online += second.bots_online;
 				info->web_clients_online += second.web_clients_online;
@@ -441,6 +442,7 @@ std::shared_ptr<DatabaseHandler::UserHistory> DatabaseHandler::list_statistics_u
 				continue; /* last server request is too old to be counted */
 
 			info->instance_online++;
+            info->instance_empty += second.web_clients_online == 0 && second.clients_online == 0;
 			info->queries_online += second.queries_online;
 			info->bots_online += second.bots_online;
 			info->web_clients_online += second.web_clients_online;
@@ -531,7 +533,7 @@ std::deque<std::unique_ptr<DatabaseHandler::GlobalVersionsStatistic>> DatabaseHa
 
 bool DatabaseHandler::register_license_upgrade(license_key_id_t old_key_id, license_key_id_t new_key_id,
         const std::chrono::system_clock::time_point &begin_timestamp, const std::chrono::system_clock::time_point &end_timestamp, const std::string &license_key) {
-    auto upgrade_id = std::chrono::system_clock::now().time_since_epoch().count();
+    auto upgrade_id = std::chrono::ceil<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
     auto sql_result = sql::command(this->sql(), "INSERT INTO `license_upgrades` (`upgrade_id`, `old_key_id`, `new_key_id`, `timestamp_begin`, `timestamp_end`, `valid`, `use_count`, `license`) VALUES"
                                                 "(:upgrade_id, :old_key_id, :new_key_id, :timestamp_begin, :timestamp_end, 1, 0, :license)",
                                                 variable{":upgrade_id", upgrade_id},

license/server/DatabaseHandler.h

@@ -70,7 +70,8 @@ namespace license::server::database {
             };
 
             struct GlobalUserStatistics : public UserStatistics {
-                uint64_t instance_online = 0;
+                uint64_t instance_online{0};
+                uint64_t instance_empty{0};
             };
 
             struct DatabaseUserStatistics : public UserStatistics {

license/server/LicenseServer.cpp

@@ -134,16 +134,19 @@ void LicenseServer::handleEventWrite(int fd, short, void* ptrServer) {
     if(!client) return;
 
     buffer::RawBuffer* write_buffer{nullptr};
+    std::unique_lock write_lock(client->network.write_queue_lock);
     while(true) { //TODO: May add some kind of timeout?
-        std::lock_guard lock(client->network.write_queue_lock);
         write_buffer = TAILQ_FIRST(&client->network.write_queue);
         if(!write_buffer) return;
 
         auto writtenBytes = send(fd, &write_buffer->buffer[write_buffer->index], write_buffer->length - write_buffer->index, 0);
         if(writtenBytes <= 0) {
+            write_lock.unlock();
         	if(writtenBytes == -1 && errno == EAGAIN)
         		return;
 	        logError(LOG_LICENSE_CONTROLL, "Invalid write. Disconnecting remote client. Message: {}/{}", errno, strerror(errno));
+	        server->unregisterClient(client);
+	        return;
         } else {
             write_buffer->index += writtenBytes;
         }
@@ -187,7 +190,7 @@ void ConnectedClient::init() {
 	TAILQ_INIT(&network.write_queue);
 }
 
-void ConnectedClient::uninit() {
+void ConnectedClient::uninit(bool blocking) {
     {
         lock_guard queue_lock{this->network.write_queue_lock};
         ts::buffer::RawBuffer* buffer;
@@ -201,11 +204,21 @@ void ConnectedClient::uninit() {
         close(this->network.fileDescriptor);
 	    network.fileDescriptor = 0;
     }
-    if(this->network.readEvent) event_del(this->network.readEvent);
-    this->network.readEvent = nullptr;
 
-    if(this->network.writeEvent) event_del(this->network.writeEvent);
-    this->network.writeEvent = nullptr;
+    std::unique_lock elock{this->network.event_mutex};
+    auto read_event = std::exchange(this->network.readEvent, nullptr);
+    auto write_event = std::exchange(this->network.writeEvent, nullptr);
+    elock.unlock();
+
+    if(blocking) {
+        if(read_event) event_del_block(read_event);
+        if(write_event) event_del_block(write_event);
+    } else {
+        if(read_event) event_del_noblock(read_event);
+        if(write_event) event_del_noblock(write_event);
+    }
+    if(read_event) event_free(read_event);
+    if(write_event) event_free(write_event);
 }
 
 void LicenseServer::handleEventRead(int fd, short, void* ptrServer) {
@@ -221,12 +234,20 @@ void LicenseServer::handleEventRead(int fd, short, void* ptrServer) {
     if(read < 0){
         if(errno == EWOULDBLOCK) return;
         logError(LOG_LICENSE_CONTROLL, "Invalid read. Disconnecting remote client. Message: {}/{}", errno, strerror(errno));
-        event_del_noblock(client->network.readEvent);
+        {
+            std::lock_guard elock{client->network.event_mutex};
+            if(client->network.readEvent)
+                event_del_noblock(client->network.readEvent);
+        }
 	    server->closeConnection(client);
         return;
     } else if(read == 0) {
         logMessage(LOG_LICENSE_CONTROLL, "[CLIENT][" + client->address() + "] Received EOF for client. Removing client.");
-        event_del_noblock(client->network.readEvent);
+        {
+            std::lock_guard elock{client->network.event_mutex};
+            if(client->network.readEvent)
+                event_del_noblock(client->network.readEvent);
+        }
 	    server->closeConnection(client);
         return;
     }
@@ -312,7 +333,7 @@ void LicenseServer::unregisterClient(const std::shared_ptr<ConnectedClient> &cli
         std::lock_guard state_lock{client->protocol.state_lock};
         client->protocol.state = protocol::UNCONNECTED;
     }
-    client->uninit();
+    client->uninit(this_thread::get_id() != this->event_base_dispatch.get_id());
 }
 
 void LicenseServer::cleanup_clients() {

license/server/LicenseServer.h

@@ -31,6 +31,8 @@ namespace license {
 		    struct {
 			    sockaddr_in remoteAddr;
 			    int fileDescriptor = 0;
+
+			    std::mutex event_mutex{};
 			    event* readEvent = nullptr; /* protected via state_lock (check state and the use these variables) */
 			    event* writeEvent = nullptr;
 
@@ -57,7 +59,7 @@ namespace license {
 		    bool invalid_license = false;
 
             void init();
-            void uninit();
+            void uninit(bool /* blocking */);
             void sendPacket(const protocol::packet&);
 
 		    inline std::string address() { return inet_ntoa(network.remoteAddr.sin_addr); }

license/server/LicenseServerHandler.cpp

@@ -188,7 +188,7 @@ bool LicenseServer::handleServerValidation(shared_ptr<ConnectedClient> &client,
 		        logMessage(LOG_GENERAL, "[CLIENT][{}] Remote license has been deleted! Shutting down server!", client->address());
 	        } else {
 		        fill_info(response.mutable_license_info(), info, remote_license->data.licenceKey);
-		        auto is_invalid = !info->isValid();
+		        auto is_invalid = !info->isNotExpired();
 		        if(is_invalid) {
                     response.set_invalid_reason("license is invalid");
                     response.set_valid(false);
@@ -198,9 +198,15 @@ bool LicenseServer::handleServerValidation(shared_ptr<ConnectedClient> &client,
 	        }
         }
 		this->manager->logRequest(remote_license->key(), client->unique_identifier, client->address(), pkt.info().version(), response.valid());
-	} else {
+	}  else {
+	    /* shall never happen, by default each server has the default license */
 	    response.set_valid(true);
 	}
+    if(pkt.has_memory_valid() && !pkt.memory_valid()) {
+        response.set_invalid_reason("server memory seems to be invalid");
+        response.set_valid(false);
+        logError(LOG_GENERAL, "Server {} has patched license memory!", client->address());
+    }
 
 	if(client->protocol.version == 2) {
         if(response.valid())

license/server/StatisticManager.cpp

@@ -139,6 +139,7 @@ std::shared_ptr<GeneralStatistics> StatisticManager::general_statistics() {
 
 	deque<unique_ptr<GeneralStatisticEntry>> entries;
 
+	//TODO: Calculate web clients!
 	auto result = sql::command(this->license_manager->sql(), "SELECT `keyId`, `unique_id`, `timestamp`,`server`,`clients`,`music` FROM `history_online` WHERE `timestamp` > :time ORDER BY `timestamp` ASC",
 				variable{":time", duration_cast<milliseconds>(system_clock::now().time_since_epoch() - hours(2) - minutes(10)).count()}) //10min as buffer
 			.query(std::function<decltype(parse_general_entry)>{parse_general_entry}, entries, true);
@@ -148,6 +149,7 @@ std::shared_ptr<GeneralStatistics> StatisticManager::general_statistics() {
 		stats->bots += entry->bots;
 		stats->clients += entry->clients;
 		stats->servers += entry->servers;
+        stats->empty_instances += entry->clients == 0;
 		stats->instances++;
 	}
 	stats->age = system_clock::now();

license/server/StatisticManager.h

@@ -5,70 +5,69 @@
 #include <chrono>
 #include "DatabaseHandler.h"
 
-namespace license {
-	namespace stats {
-		struct GeneralStatistics {
-			std::chrono::system_clock::time_point age;
+namespace license::stats {
+    struct GeneralStatistics {
+        std::chrono::system_clock::time_point age;
 
-			uint64_t instances = 0;
-			uint64_t servers = 0;
-			uint64_t clients = 0;
-			uint64_t bots = 0;
-		};
+        uint64_t empty_instances{0};
+        uint64_t instances{0};
+        uint64_t servers{0};
+        uint64_t clients{0};
+        uint64_t bots{0};
+    };
 
-		struct HistoryStatistics {
-		    enum HistoryPeriod {
-		        DAY,
-		        WEEK,
-		        MONTH,
-		        HALF_YEAR,
-		        YEAR
-		    };
-		    enum HistoryOffset {
-		        NOW,
-		        ONE_BEFORE,
-		        SEVEN_BEFORE,
-		        TWELVE_BEFORE
-		    };
-			enum HistoryType {
-				LAST_DAY,
-				DAY_YESTERDAY,
-				DAY_7DAYS_AGO,
-				LAST_WEEK,
-				LAST_MONTH,
-				LAST_HALF_YEAR
-			};
-			static std::chrono::system_clock::time_point align_type(HistoryType type, const std::chrono::system_clock::time_point&);
-			static std::chrono::milliseconds time_period(HistoryType type);
-			static std::chrono::milliseconds cache_timeout(HistoryType type);
-			static std::chrono::milliseconds type_duration(HistoryType type);
+    struct HistoryStatistics {
+        enum HistoryPeriod {
+            DAY,
+            WEEK,
+            MONTH,
+            HALF_YEAR,
+            YEAR
+        };
+        enum HistoryOffset {
+            NOW,
+            ONE_BEFORE,
+            SEVEN_BEFORE,
+            TWELVE_BEFORE
+        };
+        enum HistoryType {
+            LAST_DAY,
+            DAY_YESTERDAY,
+            DAY_7DAYS_AGO,
+            LAST_WEEK,
+            LAST_MONTH,
+            LAST_HALF_YEAR
+        };
+        static std::chrono::system_clock::time_point align_type(HistoryType type, const std::chrono::system_clock::time_point&);
+        static std::chrono::milliseconds time_period(HistoryType type);
+        static std::chrono::milliseconds cache_timeout(HistoryType type);
+        static std::chrono::milliseconds type_duration(HistoryType type);
 
-			std::chrono::system_clock::time_point evaluated;
-			std::chrono::system_clock::time_point begin;
-			std::chrono::system_clock::time_point end;
-			std::chrono::milliseconds period;
-			HistoryType type;
+        std::chrono::system_clock::time_point evaluated;
+        std::chrono::system_clock::time_point begin;
+        std::chrono::system_clock::time_point end;
+        std::chrono::milliseconds period;
+        HistoryType type;
 
-			std::shared_ptr<server::database::DatabaseHandler::UserHistory> statistics;
-		};
+        std::shared_ptr<server::database::DatabaseHandler::UserHistory> statistics;
+    };
 
-		class StatisticManager {
-			public:
-				explicit StatisticManager(std::shared_ptr<server::database::DatabaseHandler>  /* manager */);
-				virtual ~StatisticManager();
+    class StatisticManager {
+        public:
+            explicit StatisticManager(std::shared_ptr<server::database::DatabaseHandler>  /* manager */);
+            virtual ~StatisticManager();
 
-				void reset_cache_general();
-				std::shared_ptr<GeneralStatistics> general_statistics();
-				std::shared_ptr<HistoryStatistics> history(HistoryStatistics::HistoryType);
-			private:
-				std::shared_ptr<server::database::DatabaseHandler> license_manager;
+            void reset_cache_general();
+            std::shared_ptr<GeneralStatistics> general_statistics();
+            std::shared_ptr<HistoryStatistics> history(HistoryStatistics::HistoryType);
+        private:
+            std::shared_ptr<server::database::DatabaseHandler> license_manager;
 
-				std::recursive_mutex _general_statistics_lock;
-				std::recursive_mutex _general_statistics_generate_lock;
-				std::shared_ptr<GeneralStatistics> _general_statistics;
+            std::recursive_mutex _general_statistics_lock;
+            std::recursive_mutex _general_statistics_generate_lock;
+            std::shared_ptr<GeneralStatistics> _general_statistics;
 
-				std::map<HistoryStatistics::HistoryType, std::recursive_mutex> _history_locks;
-				std::map<HistoryStatistics::HistoryType, std::shared_ptr<HistoryStatistics>> _history;
-		};
-	}
+            std::map<HistoryStatistics::HistoryType, std::recursive_mutex> _history_locks;
+            std::map<HistoryStatistics::HistoryType, std::shared_ptr<HistoryStatistics>> _history;
+    };
 }

license/server/WebAPI.cpp

@@ -197,14 +197,15 @@ void WebStatistics::initialize_client(const std::shared_ptr<license::web::WebSta
 		});
 
 		{
+		    std::string error{};
 			auto options = make_shared<pipes::SSL::Options>();
 			options->type = pipes::SSL::SERVER;
 			options->context_method = TLS_method();
 			options->free_unused_keypairs = false; /* we dont want our keys get removed */
 
 			options->default_keypair({this->ssl->privateKey, this->ssl->certificate});
-			if(!client->pipe_ssl->initialize(options)) {
-				logError(LOG_LICENSE_WEB, "[{}][SSL] Failed to setup ssl! Disconnecting client", client->client_prefix());
+			if(!client->pipe_ssl->initialize(options, error)) {
+				logError(LOG_LICENSE_WEB, "[{}][SSL] Failed to setup ssl ({})! Disconnecting client", client->client_prefix(), error);
 				this->close_connection(client);
 			}
 		}
@@ -296,17 +297,21 @@ void WebStatistics::handleEventWrite(int file_descriptor, short, void* ptr_serve
 	}
 
 
-	std::lock_guard<std::recursive_mutex> lock(client->execute_lock);
+	std::unique_lock elock(client->execute_lock);
 	if(client->buffer_write.empty()) return;
 	auto& buffer = client->buffer_write.front();
 
 	auto written = send(file_descriptor, buffer.data(), buffer.length(), MSG_DONTWAIT | MSG_NOSIGNAL);
 	if(written < 0){
+		elock.unlock();
+
 		if(errno == EWOULDBLOCK) return;
 		logError(LOG_LICENSE_WEB, "[{}] Invalid write: {}/{}. Closing connection.", client->client_prefix(), errno, strerror(errno));
 		server->close_connection(client);
 		return;
 	} else if(written == 0) {
+		elock.unlock();
+
 		logError(LOG_LICENSE_WEB, "[{}] Invalid write (eof). Closing connection", client->client_prefix());
 		server->close_connection(client);
 		return;
@@ -333,17 +338,20 @@ void WebStatistics::close_connection(const std::shared_ptr<license::web::WebStat
 		else; //TODO Error handling?
 	}
 
-	std::lock_guard<std::recursive_mutex> lock(client->execute_lock);
-	if(client->event_read) {
-		event_del(client->event_read);
-		event_free(client->event_read);
-		client->event_read = nullptr;
+	std::unique_lock elock(client->execute_lock);
+	auto event_read = std::exchange(client->event_read, nullptr);
+	auto event_write = std::exchange(client->event_write, nullptr);
+	elock.unlock();
+	if(event_read) {
+		event_del(event_read);
+		event_free(event_read);
 	}
-	if(client->event_write) {
-		event_del(client->event_write);
-		event_free(client->event_write);
-		client->event_write = nullptr;
+	if(event_write) {
+		event_del(event_write);
+		event_free(event_write);
 	}
+
+	elock.lock();
 	if(client->file_descriptor > 0) {
 		if(shutdown(client->file_descriptor, SHUT_RDWR) < 0); //TODO error handling
 		if(close(client->file_descriptor) < 0); //TODO error handling
@@ -352,6 +360,7 @@ void WebStatistics::close_connection(const std::shared_ptr<license::web::WebStat
 
 	if(client->pipe_websocket)
 		client->pipe_websocket = nullptr;
+
 	if(client->pipe_ssl) {
 		client->pipe_ssl->finalize();
 		client->pipe_ssl = nullptr;
@@ -472,6 +481,7 @@ bool WebStatistics::handle_message(const std::shared_ptr<license::web::WebStatis
                     auto& history_data = response["history"]["data"];
                     for(index = 0; index < stats->record_count; index++) {
                         auto& indexed_data = history_data[index];
+                        indexed_data["instances_empty"] = stats->history[index].instance_empty;
                         indexed_data["instances"] = stats->history[index].instance_online;
                         indexed_data["servers"] = stats->history[index].servers_online;
                         indexed_data["clients"] = stats->history[index].clients_online;
@@ -519,6 +529,7 @@ bool WebStatistics::handle_message(const std::shared_ptr<license::web::WebStatis
                     auto& history_data = response["history"]["data"];
                     for(index = 0; index < data->record_count; index++) {
                         auto& indexed_data = history_data[index];
+                        indexed_data["instances_empty"] = data->history[index].instance_empty;
                         indexed_data["instances"] = data->history[index].instance_online;
                         indexed_data["servers"] = data->history[index].servers_online;
                         indexed_data["clients"] = data->history[index].clients_online;
@@ -555,16 +566,20 @@ bool WebStatistics::handle_request(const std::shared_ptr<license::web::WebStatis
 	auto type = request.parameters.at("type");
 	logMessage(LOG_LICENSE_WEB, "[{}] Received HTTP status request of type {}", client->client_prefix(), type);
 
-	if(type == "request" && request.parameters.at("request_type") == "general") {
-		Json::Value json;
-		json["type"] = "response";
-		auto stats = this->statistics_manager->general_statistics();
-		json["statistics"]["instances"] = to_string(stats->instances);
-		json["statistics"]["servers"] = to_string(stats->servers);
-		json["statistics"]["clients"] = to_string(stats->clients);
-		json["statistics"]["music"] = to_string(stats->bots);
-		response.setHeader("data", {json_dump(json).string()});
-		response.code = http::code::_200;
+	if(type == "request" && request.parameters.count("request_type") > 0) {
+	    const auto& type = request.parameters.at("request_type");
+        if(type == "general") {
+            Json::Value json;
+            json["type"] = "response";
+            auto stats = this->statistics_manager->general_statistics();
+            json["statistics"]["instances_empty"] = to_string(stats->empty_instances);
+            json["statistics"]["instances"] = to_string(stats->instances);
+            json["statistics"]["servers"] = to_string(stats->servers);
+            json["statistics"]["clients"] = to_string(stats->clients);
+            json["statistics"]["music"] = to_string(stats->bots);
+            response.setHeader("data", {json_dump(json).string()});
+            response.code = http::code::_200;
+        }
 	}
 
 	return false;

license/server/WebAPI.h

@@ -92,7 +92,6 @@ namespace license {
 				std::deque<std::shared_ptr<Client>> clients;
 
 				threads::ThreadPool scheduler{1, "WebStatistics #"};
-
 			protected:
 				static void handleEventAccept(int, short, void*);
 				static void handleEventRead(int, short, void*);

license/shared/include/license/client.h

@@ -8,7 +8,7 @@
 #include "license.h"
 
 namespace license::client {
-    class LicenseServerClient {
+    class LicenseServerClient : public std::enable_shared_from_this<LicenseServerClient> {
         public:
             enum ConnectionState {
                 CONNECTING,

license/shared/include/license/license.h

@@ -348,7 +348,7 @@ namespace license {
 	    bool deleted{false};
 	    uint32_t upgrade_id{0};
 
-        inline bool isValid() { return (end.time_since_epoch().count() == 0 || std::chrono::system_clock::now() < this->end); }
+        inline bool isNotExpired() { return (end.time_since_epoch().count() == 0 || std::chrono::system_clock::now() < this->end); }
     };
 
     extern std::shared_ptr<License> readLocalLicence(const std::string &, std::string &);

license/shared/packets/LicenseRequest.proto

@@ -41,6 +41,7 @@ message ServerValidation {
     required bool license_info      = 2;
     optional bytes license          = 3;
     optional ServerInfo info        = 4; //Change somewhere to required but its currently for legacy support
+    optional bool memory_valid      = 5;
 }
 
 message LicenseResponse {

license/shared/src/client.cpp

@@ -7,6 +7,7 @@
 #include <event.h>
 #include <ThreadPool/ThreadHelper.h>
 #include <misc/endianness.h>
+#include <shared/include/license/client.h>
 #include "shared/include/license/client.h"
 #include "crypt.h"
 
@@ -42,11 +43,16 @@ LicenseServerClient::LicenseServerClient(const sockaddr_in &address, int pversio
 }
 
 LicenseServerClient::~LicenseServerClient() {
-    this->close_connection();
+    const auto is_event_loop = this->network.event_dispatch.get_id() == std::this_thread::get_id();
+    {
+        std::unique_lock slock{this->connection_lock};
+        this->connection_state = ConnectionState::UNCONNECTED;
+    }
+    this->cleanup_network_resources(); /* force cleanup ignoring the previous state */
+    if(is_event_loop) this->network.event_dispatch.detach();
 
     if(this->buffers.read)
         Buffer::free(this->buffers.read);
-    threads::save_join(this->network.event_dispatch, false);
 }
 
 bool LicenseServerClient::start_connection(std::string &error) {
@@ -88,14 +94,25 @@ bool LicenseServerClient::start_connection(std::string &error) {
     this->network.event_base = event_base_new();
     this->network.event_read = event_new(this->network.event_base, this->network.file_descriptor, EV_READ | EV_PERSIST, [](int, short e, void* _this) {
         auto client = reinterpret_cast<LicenseServerClient*>(_this);
+        auto client_ref = client->weak_from_this().lock();
+        if(!client_ref) {
+            logCritical(0, "Network callback for expired client (E011)!");
+            return;
+        }
         client->callback_read(e);
+        client_ref.reset();
     }, this);
     this->network.event_write = event_new(this->network.event_base, this->network.file_descriptor, EV_WRITE, [](int, short e, void* _this) {
         auto client = reinterpret_cast<LicenseServerClient*>(_this);
+        auto client_ref = client->weak_from_this().lock();
+        if(!client_ref) {
+            logCritical(0, "Network callback for expired client (E012)!");
+            return;
+        }
         client->callback_write(e);
+        client_ref.reset();
     }, this);
 
-    event_dispatch_spawned = true;
     this->network.event_dispatch = std::thread([&] {
         signal(SIGPIPE, SIG_IGN);
 
@@ -114,10 +131,6 @@ bool LicenseServerClient::start_connection(std::string &error) {
     return true;
     error_cleanup:
     this->cleanup_network_resources();
-    if(!event_dispatch_spawned) {
-        event_base_free(this->network.event_base);
-        this->network.event_base = nullptr;
-    }
     this->connection_state = ConnectionState::UNCONNECTED;
     return false;
 }
@@ -164,7 +177,7 @@ void LicenseServerClient::cleanup_network_resources() {
         auto buffer = TAILQ_FIRST(&this->buffers.write);
         while(buffer) {
             auto next = TAILQ_NEXT(buffer, tail);
-            Buffer::free(next);
+            Buffer::free(buffer);
             buffer = next;
         }
         TAILQ_INIT(&this->buffers.write);
@@ -243,8 +256,11 @@ void LicenseServerClient::callback_write(short events) {
     }
 
     if(events & EV_WRITE) {
-        if(this->connection_state == ConnectionState::CONNECTING)
+        if(this->connection_state == ConnectionState::CONNECTING) {
             this->callback_socket_connected();
+            if(this->connection_state == ConnectionState::UNCONNECTED) /* state may change in the callback */
+                return;
+        }
 
         ssize_t written_bytes{0};
 
@@ -365,6 +381,8 @@ void LicenseServerClient::handle_data(void *recv_buffer, size_t length) {
         if(buffer_length < header->length + sizeof(protocol::packet_header)) return;
 
         this->handle_raw_packet(header->packetId, buffer_ptr + buffer_offset + sizeof(protocol::packet_header), header->length);
+        if(this->connection_state == ConnectionState::UNCONNECTED) return; /* state may change while we're handing the packet */
+
         buffer_offset += header->length + sizeof(protocol::packet_header);
         buffer_length -= header->length + sizeof(protocol::packet_header);
     }

server/CMakeLists.txt

@@ -39,7 +39,8 @@ set(CMAKE_VERBOSE_MAKEFILE ON)
 set(SERVER_SOURCE_FILES
         main.cpp
         tomcryptTest.cpp
-        MySQLLibSSLFix.c
+        # Only needed for boringssl
+        # MySQLLibSSLFix.c
 
         src/client/ConnectedClient.cpp
         src/client/voice/PrecomputedPuzzles.cpp
@@ -48,6 +49,7 @@ set(SERVER_SOURCE_FILES
         src/client/voice/VoiceClientCommandHandler.cpp
         src/client/voice/VoiceClientPacketHandler.cpp
         src/client/voice/VoiceClientView.cpp
+        src/client/voice/PacketStatistics.cpp
         src/TS3ServerClientManager.cpp
         src/VirtualServer.cpp
         src/TS3ServerHeartbeat.cpp
@@ -60,10 +62,11 @@ set(SERVER_SOURCE_FILES
         src/client/command_handler/client.cpp
         src/client/command_handler/server.cpp
         src/client/command_handler/misc.cpp
+        src/client/command_handler/bulk_parsers.cpp
 
         src/client/ConnectedClientNotifyHandler.cpp
         src/VirtualServerManager.cpp
-        src/server/file/FileServer.cpp
+        src/server/file/LocalFileServer.cpp
         src/channel/ServerChannel.cpp
         src/channel/ClientChannelView.cpp
         src/client/file/FileClient.cpp
@@ -80,7 +83,6 @@ set(SERVER_SOURCE_FILES
         src/client/query/QueryClientCommands.cpp
         src/client/query/QueryClientNotify.cpp
 
-
         src/manager/IpListManager.cpp
 
         src/ConnectionStatistics.cpp
@@ -135,6 +137,13 @@ set(SERVER_SOURCE_FILES
         src/weblist/WebListManager.cpp
         src/weblist/TeamSpeakWebClient.cpp
 
+        src/snapshots/permission.cpp
+        src/snapshots/client.cpp
+        src/snapshots/channel.cpp
+        src/snapshots/server.cpp
+        src/snapshots/groups.cpp
+        src/snapshots/deploy.cpp
+
         src/manager/ConversationManager.cpp
         src/client/SpeakingClientHandshake.cpp
         src/client/command_handler/music.cpp src/client/command_handler/file.cpp)
@@ -234,7 +243,7 @@ target_link_libraries(PermMapHelper
 
 SET(CPACK_PACKAGE_VERSION_MAJOR "1")
 SET(CPACK_PACKAGE_VERSION_MINOR "4")
-SET(CPACK_PACKAGE_VERSION_PATCH "10")
+SET(CPACK_PACKAGE_VERSION_PATCH "14")
 if (BUILD_TYPE_NAME EQUAL OFF)
     SET(CPACK_PACKAGE_VERSION_DATA "beta")
 elseif (BUILD_TYPE_NAME STREQUAL "")
@@ -280,10 +289,16 @@ target_link_libraries(TeaSpeakServer
 )
 
 if (COMPILE_WEB_CLIENT)
-    target_link_libraries(TeaSpeakServer ${glib20_DIR}/lib/x86_64-linux-gnu/libffi.so.7 ${nice_DIR}/lib/libnice.so.10)
+    file(GLOB GLIB20_ARCHS ${glib20_DIR}/lib/*)
+    list(LENGTH GLIB20_ARCHS GLIB20_ARCHS_LENGTH)
+    if (NOT ${GLIB20_ARCHS_LENGTH} EQUAL 1)
+        message(FATAL_ERROR "Missing arch specific folder for glib2.0 in ${glib20_DIR}. Found ${GLIB20_ARCHS_LENGTH} directories, expected 1.")
+    endif ()
+    list(GET GLIB20_ARCHS 0 GLIB20_ARCH_DIR)
+    target_link_libraries(TeaSpeakServer ${GLIB20_ARCH_DIR}/libffi.so.7 ${nice_DIR}/lib/libnice.so.10)
 endif ()
 
-include_directories(${LIBRARY_PATH}/boringssl/include/)
+# include_directories(${LIBRARY_PATH}/boringssl/include/)
 target_link_libraries(TeaSpeakServer
         openssl::ssl::shared
         openssl::crypto::shared
@@ -306,4 +321,25 @@ if (NOT DISABLE_JEMALLOC)
             jemalloc
     )
     add_definitions(-DHAVE_JEMALLOC)
-endif ()
+endif ()
+
+
+add_executable(Snapshots-Permissions-Test src/snapshots/permission.cpp tests/snapshots/permission.cpp)
+target_link_libraries(Snapshots-Permissions-Test PUBLIC
+    TeaSpeak
+    CXXTerminal::static  #Static
+    ${StringVariable_LIBRARIES_STATIC}
+    ${YAML_CPP_LIBRARIES}
+    pthread
+    stdc++fs
+    libevent::core libevent::pthreads
+
+    #Require a so
+    sqlite3
+    DataPipes::rtc::shared
+
+    tomcrypt::static
+    tommath::static
+    ${glib20_DIR}/lib/x86_64-linux-gnu/libffi.so.7 ${nice_DIR}/lib/libnice.so.10
+)
+target_include_directories(Snapshots-Permissions-Test PUBLIC ${CMAKE_SOURCE_DIR}/server/src/)

server/environment/geoloc

@@ -1 +0,0 @@
-../repro/env/geoloc/

server/environment/providers

@@ -1 +0,0 @@
-../../music/bin/providers/

server/environment/resources

@@ -1 +0,0 @@
-../repro/env/resources/

server/main.cpp

@@ -10,7 +10,7 @@
 #include "src/VirtualServer.h"
 #include "src/InstanceHandler.h"
 #include "src/server/QueryServer.h"
-#include "src/server/file/FileServer.h"
+#include "src/server/file/LocalFileServer.h"
 #include "src/terminal/CommandHandler.h"
 #include "src/client/InternalClient.h"
 #include "src/SignalHandler.h"
@@ -44,11 +44,10 @@ extern void testTomMath();
     #define DB_NAME "TeaData.sqlite"
 #endif
 
-#include <regex>
 #include <codecvt>
 #include "src/client/music/internal_provider/channel_replay/ChannelProvider.h"
 
-class CLIParser{
+class CLIParser {
     public:
         CLIParser (int &argc, char **argv){
             for (int i = 1; i < argc; i++)
@@ -129,7 +128,6 @@ int main(int argc, char** argv) {
         terminal::install();
         if(!terminal::active()){ cerr << "could not setup terminal!" << endl; return -1; }
     }
-    assert(ts::property::impl::validateUnique());
 
     if(arguments.cmdOptionExists("--help") || arguments.cmdOptionExists("-h")) {
         #define HELP_FMT "  {} {} | {}"
@@ -265,7 +263,7 @@ int main(int argc, char** argv) {
     if(!cfgErrors.empty()){
         logErrorFmt(true, LOG_GENERAL, "Could not load configuration. Errors: (" + to_string(cfgErrors.size()) + ")");
         for(const auto& entry : cfgErrors)
-            logError(true, LOG_GENERAL, " - {}", entry);
+            logErrorFmt(true, LOG_GENERAL, " - {}", entry);
         logErrorFmt(true, LOG_GENERAL, "Stopping server...");
         goto stopApp;
     }
@@ -309,6 +307,32 @@ int main(int argc, char** argv) {
         logMessageFmt(true, LOG_GENERAL, strobf("[]---------------------------------------------------------[]").string());
     }
 
+    {
+        rlimit rlimit{0, 0};
+        //forum.teaspeak.de/index.php?threads/2570/
+        constexpr auto seek_help_message = "Fore more help visit the forum and read this thread (https://forum.teaspeak.de/index.php?threads/2570/).";
+        if(getrlimit(RLIMIT_NOFILE, &rlimit) != 0) {
+            //prlimit -n4096 -p pid_of_process
+            logWarningFmt(true, LOG_INSTANCE, "Failed to get open file rlimit ({}). Please ensure its over 16384.", strerror(errno));
+            logWarningFmt(true, LOG_INSTANCE, seek_help_message);
+        } else {
+            const auto original = rlimit.rlim_cur;
+            rlimit.rlim_cur = std::max(rlimit.rlim_cur, std::min(rlimit.rlim_max, (rlim_t) 16384));
+            if(original != rlimit.rlim_cur) {
+                if(setrlimit(RLIMIT_NOFILE, &rlimit) != 0) {
+                    logErrorFmt(true, LOG_INSTANCE, "Failed to set open file rlimit to {} ({}). Please ensure its over 16384.", rlimit.rlim_cur, strerror(errno));
+                    logWarningFmt(true, LOG_INSTANCE, seek_help_message);
+                    goto rlimit_updates;
+                }
+            }
+            if(rlimit.rlim_cur < 16384) {
+                logWarningFmt(true, LOG_INSTANCE, "Open file rlimit is bellow 16384 ({}). Please increase the system file descriptor limits.", rlimit.rlim_cur);
+                logWarningFmt(true, LOG_INSTANCE, seek_help_message);
+            }
+        }
+        rlimit_updates:;
+    }
+
     logMessage(LOG_GENERAL, "Starting TeaSpeak-Server v{}", build::version()->string(true));
     logMessage(LOG_GENERAL, "Starting music providers");
 
@@ -371,18 +395,13 @@ int main(int argc, char** argv) {
         auto password = arguments.cmdOptionExists("-q") ? arguments.get_option("-q") : arguments.get_option("--set_query_password");
         if(!password.empty()) {
             logMessageFmt(true, LOG_GENERAL, "Updating server admin query password to \"{}\"", password);
-            auto accounts = serverInstance->getQueryServer()->find_query_accounts_by_unique_id(serverInstance->getInitialServerAdmin()->getUid());
-            bool found = false;
-            for(const auto& account : accounts) {
-                if(account->bound_server != 0) continue;
+            auto account = serverInstance->getQueryServer()->find_query_account_by_name("serveradmin");
+            if(!account) {
+                logErrorFmt(true, LOG_GENERAL, "Failed to update server admin query password! Login does not exists!");
+            } else {
                 if(!serverInstance->getQueryServer()->change_query_password(account, password)) {
                     logErrorFmt(true, LOG_GENERAL, "Failed to update server admin query password! (Internal error)");
                 }
-                found = true;
-                break;
-            }
-            if(!found) {
-                logErrorFmt(true, LOG_GENERAL, "Failed to update server admin query password! Login does not exists!");
             }
         }
     }

server/repro/build.sh

@@ -6,6 +6,39 @@ if [[ -z "${BUILD_PATH}" ]]; then
     exit 1
 fi
 
+rm buildVersion.txt
+cp env/buildVersion.txt .
+rm -r env
+mkdir env
+cd env
+[[ $? -ne 0 ]] && {
+  echo "Failed to create the env"
+  exit 1
+}
+cp -rf ../../../git-teaspeak/default_files/{certs,commanddocs,geoloc,resources,*.sh} .
+[[ $? -ne 0 ]] && {
+  echo "Failed to copy env"
+  exit 1
+}
+
+cp -rf ../../../music/bin/providers .
+[[ $? -ne 0 ]] && {
+  echo "Failed to copy providers"
+  exit 1
+}
+#
+cp ../../environment/TeaSpeakServer .
+[[ $? -ne 0 ]] && {
+  echo "Failed to copy server"
+  exit 1
+}
+cd ..
+mv buildVersion.txt env/buildVersion.txt
+[[ $? -ne 0 ]] && {
+  echo "Failed to move the build version back"
+  exit 1
+}
+
 ./generate_version.sh "${BUILD_PATH}" || {
     echo "Failed to generate version! ($?)"
     exit 1
@@ -24,4 +57,4 @@ fi
 ./deploy_build.sh "${BUILD_PATH}" || {
     echo "Failed to deploy package! ($?)"
     exit 1
-}
+}

server/repro/env/TeaSpeakServer

@@ -1 +0,0 @@
-../../environment/TeaSpeakServer

server/repro/env/certs

@@ -1 +0,0 @@
-../../../git-teaspeak/default_files/certs/

server/repro/env/commanddocs

@@ -1 +0,0 @@
-../../../git-teaspeak/default_files/commanddocs/

server/repro/env/geoloc

@@ -1 +0,0 @@
-../../../git-teaspeak/default_files/geoloc/

server/repro/env/install_music.sh

@@ -1 +0,0 @@
-../../../git-teaspeak/default_files/install_music.sh

server/repro/env/providers

@@ -1 +0,0 @@
-../../../music/bin/providers/

server/repro/env/resources

@@ -1 +0,0 @@
-../../../git-teaspeak/default_files/resources/

server/repro/env/tealoop.sh

@@ -1 +0,0 @@
-../../../git-teaspeak/default_files/tealoop.sh

server/repro/env/teastart.sh

@@ -1 +0,0 @@
-../../../git-teaspeak/default_files/teastart.sh

server/repro/env/teastart_autorestart.sh

@@ -1 +0,0 @@
-../../../git-teaspeak/default_files/teastart_autorestart.sh

server/repro/env/teastart_minimal.sh

@@ -1 +0,0 @@
-../../../git-teaspeak/default_files/teastart_minimal.sh

server/repro/generate_libraries.sh

@@ -3,7 +3,7 @@
 #Required libraries:
 # "libssl.so"
 # "libcrypto.so"
-# "libDataPipes.so"
+# "libDataPipes-Rtc-Shared.so"
 # "libjemalloc.so.2"
 # "libsqlite3.so.0"
 # "libTeaMusic.so"
@@ -42,16 +42,16 @@ cd libs || { echo "failed to enter lib directory"; exit 1; }
 library_base=$(realpath ../../../../../libraries)
 
 # Setting up ssl
-library_path=$(realpath "${library_base}/boringssl/${build_path}/ssl/libssl.so")
-cp "$library_path" . || { echo "failed to copy libssl.so"; exit 1; }
+query_system_link "libssl.so.1.1"
+cp "${library_path}" . || { echo "failed to copy libssl.so.1.1"; exit 1; }
 
 # Setting up crypto
-library_path=$(realpath "${library_base}/boringssl/${build_path}/crypto/libcrypto.so")
-cp "$library_path" . || { echo "failed to copy libcrypto.so"; exit 1; }
+query_system_link "libcrypto.so.1.1"
+cp "${library_path}" . || { echo "failed to copy libcrypto.so.1.1"; exit 1; }
 
 # Setting up DataPipes
-library_path=$(realpath "${library_base}/DataPipes/${build_path}/lib/libDataPipes-RTC.so")
-cp "$library_path" . || { echo "failed to copy libDataPipes-RTC.so"; exit 1; }
+library_path=$(realpath "${library_base}/DataPipes/${build_path}/lib/libDataPipes-Rtc-Shared.so")
+cp "$library_path" . || { echo "failed to copy libDataPipes-Rtc-Shared.so"; exit 1; }
 _dp_path="$library_path"
 
 # Setting up Sqlite3

server/src/Configuration.cpp

@@ -52,8 +52,18 @@ bool config::server::badges::allow_overwolf;
 bool config::server::authentication::name;
 
 bool config::server::clients::teamspeak;
+std::string config::server::clients::extra_welcome_message_teamspeak;
+config::server::clients::WelcomeMessageType config::server::clients::extra_welcome_message_type_teamspeak;
+
 bool config::server::clients::teaweb;
+std::string config::server::clients::extra_welcome_message_teaweb;
+config::server::clients::WelcomeMessageType config::server::clients::extra_welcome_message_type_teaweb;
+
 bool config::server::clients::teaspeak;
+std::string config::server::clients::extra_welcome_message_teaspeak;
+config::server::clients::WelcomeMessageType config::server::clients::extra_welcome_message_type_teaspeak;
+
+bool config::server::clients::ignore_max_clone_permissions;
 
 uint16_t config::voice::default_voice_port;
 size_t config::voice::DefaultPuzzlePrecomputeSize;
@@ -115,8 +125,12 @@ bool config::web::activated;
 std::deque<std::tuple<std::string, std::string, std::string>> config::web::ssl::certificates;
 uint16_t config::web::webrtc_port_max;
 uint16_t config::web::webrtc_port_min;
-deque<string> config::web::ice_servers;
+bool config::web::stun_enabled;
+std::string config::web::stun_host;
+uint16_t config::web::stun_port;
 bool config::web::enable_upnp;
+bool config::web::udp_enabled;
+bool config::web::tcp_enabled;
 
 size_t config::log::vs_size;
 std::string config::log::path;
@@ -468,7 +482,6 @@ vector<string> config::parseConfig(const std::string& path) {
                 goto license_parsing;
             }
 
-            /*
             if(!config::license->isValid()) {
                 if(config::license->data.type == license::LicenseType::INVALID) {
                     errors.emplace_back(strobf("Give license isn't valid!").string());
@@ -478,38 +491,18 @@ vector<string> config::parseConfig(const std::string& path) {
                 logErrorFmt(true, LOG_GENERAL, strobf("The given license isn't valid!").string());
                 logErrorFmt(true, LOG_GENERAL, strobf("Falling back to the default license.").string());
                 teaspeak_license = "none";
+
                 goto license_parsing;
             }
-             */
         }
 
         {
             auto bindings = create_bindings();
             read_bindings(config, bindings);
             build_comments(comments, bindings);
-
-            for(const auto& entry : config::web::ice_servers) {
-                auto dp = entry.find(':');
-                if(dp == string::npos) {
-                    errors.emplace_back("Invalid ice server entry! Missing port");
-                    continue;
-                }
-                auto host = entry.substr(0, dp);
-                auto port = entry.substr(dp + 1);
-                if(port.find_last_not_of("0123456789") != string::npos)  {
-                    errors.push_back("Invalid ice server entry! Invalid port (" + port + ")");
-                    continue;
-                }
-
-                try {
-                    stoi(port);
-                } catch(std::exception& ex) {
-                    errors.push_back("Invalid ice server entry! Invalid port (" + port + ")");
-                }
-            }
         }
 
-        auto currentVersion = strobf("TeaSpeak ").string() + build::version()->string(true);
+        auto currentVersion = config::server::default_version();
         if(currentVersion != config::server::DefaultServerVersion) {
             auto ref = config::server::DefaultServerVersion;
             try {
@@ -1107,17 +1100,18 @@ std::deque<std::shared_ptr<EntryBinding>> config::create_bindings() {
         BIND_GROUP(query);
         {
             CREATE_BINDING("nl_char", 0);
-            BIND_STRING(config::query::newlineCharacter, "\r\n");
+            BIND_STRING(config::query::newlineCharacter, "\n");
             ADD_DESCRIPTION("Change the query newline character");
+            ADD_NOTE("NOTE: TS3 - Compatible bots may require \"\n\r\"");
         }
         {
             CREATE_BINDING("motd", 0);
-            BIND_STRING(config::query::motd, "TeaSpeak\r\nWelcome on the TeaSpeak ServerQuery interface.\r\n");
+            BIND_STRING(config::query::motd, "TeaSpeak\nWelcome on the TeaSpeak ServerQuery interface.\n");
             ADD_DESCRIPTION("The query welcome message");
 
             ADD_NOTE("If not like TeamSpeak then some applications may not recognize the Query");
             ADD_NOTE("Default TeamSpeak 3 MOTD:");
-            ADD_NOTE("TS3\r\nWelcome to the TeamSpeak 3 ServerQuery interface, type \"help\" for a list of commands and \"help <command>\" for information on a specific command.\r\n");
+            ADD_NOTE("TS3\n\rWelcome to the TeamSpeak 3 ServerQuery interface, type \"help\" for a list of commands and \"help <command>\" for information on a specific command.\n\r");
             ADD_NOTE("NOTE: Sometimes you have to append one \r\n more!");
         }
         {
@@ -1317,13 +1311,60 @@ std::deque<std::shared_ptr<EntryBinding>> config::create_bindings() {
             }
         }
         {
+            using WelcomeMessageType = config::server::clients::WelcomeMessageType;
             BIND_GROUP(clients);
+
+            /* TeamSpeak */
             {
                 CREATE_BINDING("teamspeak", FLAG_RELOADABLE);
                 BIND_BOOL(config::server::clients::teamspeak, true);
                 ADD_DESCRIPTION("Allow/disallow the TeamSpeak 3 client to join the server.");
                 ADD_NOTE_RELOADABLE();
             }
+            {
+                CREATE_BINDING("teamspeak_message", FLAG_RELOADABLE);
+                BIND_STRING(config::server::clients::extra_welcome_message_teamspeak, "");
+                ADD_DESCRIPTION("Add an extra welcome message for TeamSpeak client users");
+                ADD_NOTE_RELOADABLE();
+            }
+            {
+                CREATE_BINDING("teamspeak_message_type", FLAG_RELOADABLE);
+                BIND_INTEGRAL(config::server::clients::extra_welcome_message_type_teamspeak, WelcomeMessageType::WELCOME_MESSAGE_TYPE_NONE, WelcomeMessageType::WELCOME_MESSAGE_TYPE_MIN, WelcomeMessageType::WELCOME_MESSAGE_TYPE_MAX);
+                ADD_DESCRIPTION("The welcome message type modes");
+                ADD_DESCRIPTION(std::to_string(WelcomeMessageType::WELCOME_MESSAGE_TYPE_NONE) + " - None, do nothing");
+                ADD_DESCRIPTION(std::to_string(WelcomeMessageType::WELCOME_MESSAGE_TYPE_CHAT) + " - Message, sends this message before the server welcome message");
+                ADD_DESCRIPTION(std::to_string(WelcomeMessageType::WELCOME_MESSAGE_TYPE_POKE) + " - Message, pokes the client with the message when he enters the server");
+                ADD_NOTE_RELOADABLE();
+            }
+
+            /* TeaSpeak */
+            /*
+            {
+                CREATE_BINDING("teaspeak", FLAG_RELOADABLE);
+                BIND_BOOL(config::server::clients::teaspeak, true);
+                ADD_DESCRIPTION("Allow/disallow the TeaSpeak - Client to join the server.");
+                ADD_NOTE_RELOADABLE();
+            }
+            */
+            config::server::clients::teaspeak = true;
+            {
+                CREATE_BINDING("teaspeak_message", FLAG_RELOADABLE);
+                BIND_STRING(config::server::clients::extra_welcome_message_teaspeak, "");
+                ADD_DESCRIPTION("Add an extra welcome message for the TeaSpeak - Client users");
+                ADD_NOTE_RELOADABLE();
+            }
+            {
+                CREATE_BINDING("teaspeak_message_type", FLAG_RELOADABLE);
+                BIND_INTEGRAL(config::server::clients::extra_welcome_message_type_teaspeak, WelcomeMessageType::WELCOME_MESSAGE_TYPE_NONE, WelcomeMessageType::WELCOME_MESSAGE_TYPE_MIN, WelcomeMessageType::WELCOME_MESSAGE_TYPE_MAX);
+                ADD_DESCRIPTION("The welcome message type modes");
+                ADD_DESCRIPTION(std::to_string(WelcomeMessageType::WELCOME_MESSAGE_TYPE_NONE) + " - None, do nothing");
+                ADD_DESCRIPTION(std::to_string(WelcomeMessageType::WELCOME_MESSAGE_TYPE_CHAT) + " - Message, sends this message before the server welcome message");
+                ADD_DESCRIPTION(std::to_string(WelcomeMessageType::WELCOME_MESSAGE_TYPE_POKE) + " - Message, pokes the client with the message when he enters the server");
+                ADD_NOTE_RELOADABLE();
+            }
+
+
+            /* TeaWeb */
             {
                 CREATE_BINDING("teaweb", FLAG_RELOADABLE);
                 BIND_BOOL(config::server::clients::teaweb, true);
@@ -1331,9 +1372,26 @@ std::deque<std::shared_ptr<EntryBinding>> config::create_bindings() {
                 ADD_NOTE_RELOADABLE();
             }
             {
-                CREATE_BINDING("teaspeak", FLAG_RELOADABLE);
-                BIND_BOOL(config::server::clients::teaspeak, true);
-                ADD_DESCRIPTION("Allow/disallow the TeaSpeak - Client to join the server.");
+                CREATE_BINDING("teaweb_message", FLAG_RELOADABLE);
+                BIND_STRING(config::server::clients::extra_welcome_message_teaweb, "");
+                ADD_DESCRIPTION("Add an extra welcome message for the TeaSpeak - Web client users");
+                ADD_NOTE_RELOADABLE();
+            }
+            {
+                CREATE_BINDING("teaweb_message_type", FLAG_RELOADABLE);
+                BIND_INTEGRAL(config::server::clients::extra_welcome_message_type_teaweb, WelcomeMessageType::WELCOME_MESSAGE_TYPE_NONE, WelcomeMessageType::WELCOME_MESSAGE_TYPE_MIN, WelcomeMessageType::WELCOME_MESSAGE_TYPE_MAX);
+                ADD_DESCRIPTION("The welcome message type modes");
+                ADD_DESCRIPTION(std::to_string(WelcomeMessageType::WELCOME_MESSAGE_TYPE_NONE) + " - None, do nothing");
+                ADD_DESCRIPTION(std::to_string(WelcomeMessageType::WELCOME_MESSAGE_TYPE_CHAT) + " - Message, sends this message before the server welcome message");
+                ADD_DESCRIPTION(std::to_string(WelcomeMessageType::WELCOME_MESSAGE_TYPE_POKE) + " - Message, pokes the client with the message when he enters the server");
+                ADD_NOTE_RELOADABLE();
+            }
+
+            {
+                CREATE_BINDING("ignore_max_clone_permissions", FLAG_RELOADABLE);
+                BIND_BOOL(config::server::clients::ignore_max_clone_permissions, false);
+                ADD_DESCRIPTION("Allows you to disable the permission checks for i_client_max_clones_uid, i_client_max_clones_ip and i_client_max_clones_hwid");
+                ADD_SENSITIVE();
                 ADD_NOTE_RELOADABLE();
             }
         }
@@ -1426,9 +1484,34 @@ std::deque<std::shared_ptr<EntryBinding>> config::create_bindings() {
             ADD_NOTE("These ports must opened to use the voice bridge (Protocol: UDP)");
         }
         {
-            CREATE_BINDING("webrtc.ice", 0);
-            BIND_VECTOR(config::web::ice_servers, {"stun.l.google.com:19302"});
-            ADD_DESCRIPTION("A list of possible offered ice servers");
+            CREATE_BINDING("webrtc.stun.enabled", 0);
+            BIND_INTEGRAL(config::web::stun_enabled, false, false, true);
+            ADD_DESCRIPTION("Whatever to use a STUN server");
+            ADD_NOTE_RELOADABLE();
+        }
+        {
+            CREATE_BINDING("webrtc.stun.host", 0);
+            BIND_STRING(config::web::stun_host, "stun.l.google.com");
+            ADD_DESCRIPTION("Stun hostname");
+            ADD_NOTE_RELOADABLE();
+        }
+        {
+            CREATE_BINDING("webrtc.stun.port", 0);
+            BIND_INTEGRAL(config::web::stun_port, 19302, 1, 0xFFFF);
+            ADD_DESCRIPTION("Port of the stun server");
+            ADD_NOTE_RELOADABLE();
+        }
+        {
+            CREATE_BINDING("webrtc.udp", 0);
+            BIND_INTEGRAL(config::web::udp_enabled, true, false, true);
+            ADD_DESCRIPTION("Enable UDP for theweb client");
+            ADD_NOTE_RELOADABLE();
+        }
+        {
+            CREATE_BINDING("webrtc.tcp", 0);
+            BIND_INTEGRAL(config::web::tcp_enabled, true, false, true);
+            ADD_DESCRIPTION("Enable TCP for theweb client");
+            ADD_NOTE_RELOADABLE();
         }
     }
     {

server/src/Configuration.h

@@ -7,8 +7,10 @@
     #undef byte
 #endif
 #include <spdlog/common.h>
+#include <misc/strobf.h>
 #include "geo/GeoLocation.h"
 #include "../../license/shared/include/license/license.h"
+#include "build.h"
 
 namespace YAML {
     class Node;
@@ -86,12 +88,35 @@ namespace ts::config {
         }
 
         namespace clients {
+            enum WelcomeMessageType {
+                WELCOME_MESSAGE_TYPE_MIN,
+                WELCOME_MESSAGE_TYPE_NONE = WELCOME_MESSAGE_TYPE_MIN,
+                WELCOME_MESSAGE_TYPE_CHAT,
+                WELCOME_MESSAGE_TYPE_POKE,
+                WELCOME_MESSAGE_TYPE_MAX
+            };
+
             extern bool teamspeak;
+            extern std::string extra_welcome_message_teamspeak;
+            extern WelcomeMessageType extra_welcome_message_type_teamspeak;
+
             extern bool teaspeak;
+            extern std::string extra_welcome_message_teaspeak;
+            extern WelcomeMessageType extra_welcome_message_type_teaspeak;
+
             extern bool teaweb;
+            extern std::string extra_welcome_message_teaweb;
+            extern WelcomeMessageType extra_welcome_message_type_teaweb;
+
+            extern bool ignore_max_clone_permissions;
         }
 
         extern ssize_t max_virtual_server;
+
+        __attribute__((always_inline)) inline std::string default_version() { return strobf("TeaSpeak ").string() + build::version()->string(true); }
+        __attribute__((always_inline)) inline bool check_server_version_with_license() {
+            return default_version() == DefaultServerVersion || (license->isPremium() && license->isValid());
+        }
     }
 
     namespace voice {
@@ -185,8 +210,15 @@ namespace ts::config {
 
         extern uint16_t webrtc_port_min;
         extern uint16_t webrtc_port_max;
-        extern std::deque<std::string> ice_servers;
+
         extern bool enable_upnp;
+
+        extern bool stun_enabled;
+        extern std::string stun_host;
+        extern uint16_t stun_port;
+
+        extern bool tcp_enabled;
+        extern bool udp_enabled;
     }
 
     namespace threads {

server/src/ConnectionStatistics.cpp

@@ -3,8 +3,9 @@
 //
 
 #include <misc/memtracker.h>
+
+#include <utility>
 #include "ConnectionStatistics.h"
-#include "VirtualServer.h"
 
 using namespace std;
 using namespace std::chrono;
@@ -13,321 +14,98 @@ using namespace ts::server;
 using namespace ts::stats;
 using namespace ts::protocol;
 
-ConnectionStatistics::ConnectionStatistics(const shared_ptr<ConnectionStatistics>& handle, bool properties) : handle(handle) {
+ConnectionStatistics::ConnectionStatistics(shared_ptr<ConnectionStatistics> handle) : handle(std::move(handle)) {
     memtrack::allocated<ConnectionStatistics>(this);
-
-    if(properties) {
-        this->properties = make_shared<Properties>(); //TODO load etc?
-        this->properties->register_property_type<property::ConnectionProperties>();
-    }
-
-    /*
-    this->properties->registerProperty("connection_packets_sent_speech", 0, PROP_STATISTIC);
-    this->properties->registerProperty("connection_bytes_sent_speech", 0, PROP_STATISTIC);
-    this->properties->registerProperty("connection_packets_received_speech", 0, PROP_STATISTIC);
-    this->properties->registerProperty("connection_bytes_received_speech", 0, PROP_STATISTIC);
-
-    this->properties->registerProperty("connection_packets_sent_keepalive", 0, PROP_STATISTIC);
-    this->properties->registerProperty("connection_bytes_sent_keepalive", 0, PROP_STATISTIC);
-    this->properties->registerProperty("connection_packets_received_keepalive", 0, PROP_STATISTIC);
-    this->properties->registerProperty("connection_bytes_received_keepalive", 0, PROP_STATISTIC);
-
-    this->properties->registerProperty("connection_packets_sent_control", 0, PROP_STATISTIC);
-    this->properties->registerProperty("connection_bytes_sent_control", 0, PROP_STATISTIC);
-    this->properties->registerProperty("connection_packets_received_control", 0, PROP_STATISTIC);
-    this->properties->registerProperty("connection_bytes_received_control", 0, PROP_STATISTIC);
-
-    this->properties->registerProperty("connection_packets_sent_total", 0, PROP_STATISTIC);
-    this->properties->registerProperty("connection_bytes_sent_total", 0, PROP_STATISTIC);
-    this->properties->registerProperty("connection_packets_received_total", 0, PROP_STATISTIC);
-    this->properties->registerProperty("connection_bytes_received_total", 0, PROP_STATISTIC);
-
-    this->properties->registerProperty("connection_bandwidth_sent_last_second_total", 0, PROP_STATISTIC);
-    this->properties->registerProperty("connection_bandwidth_sent_last_minute_total", 0, PROP_STATISTIC);
-    this->properties->registerProperty("connection_bandwidth_received_last_second_total", 0, PROP_STATISTIC);
-    this->properties->registerProperty("connection_bandwidth_received_last_minute_total", 0, PROP_STATISTIC);
-
-    this->properties->registerProperty("connection_filetransfer_bandwidth_sent", 0, PROP_STATISTIC);
-    this->properties->registerProperty("connection_filetransfer_bandwidth_received", 0, PROP_STATISTIC);
-    this->properties->registerProperty("connection_filetransfer_bytes_sent_total", 0, PROP_STATISTIC);
-    this->properties->registerProperty("connection_filetransfer_bytes_received_total", 0, PROP_STATISTIC);
-    */
 }
 
 ConnectionStatistics::~ConnectionStatistics() {
     memtrack::freed<ConnectionStatistics>(this);
-
-    {
-        lock_guard lock(this->history_lock_incoming);
-
-        for(auto entry : this->history_incoming)
-            if(entry->use_count.fetch_sub(1) == 1)
-                delete entry;
-        for(auto entry : this->history_file_incoming)
-            if(entry->use_count.fetch_sub(1) == 1)
-                delete entry;
-
-        this->history_incoming.clear();
-        this->history_file_incoming.clear();
-    }
-    {
-        lock_guard lock(this->history_lock_outgoing);
-
-        for(auto entry : this->history_outgoing)
-            if(entry->use_count.fetch_sub(1) == 1)
-                delete entry;
-        for(auto entry : this->history_file_outgoing)
-            if(entry->use_count.fetch_sub(1) == 1)
-                delete entry;
-
-        this->history_outgoing.clear();
-        this->history_file_outgoing.clear();
-    }
-}
-
-std::shared_ptr<Properties> ConnectionStatistics::statistics() {
-    return this->properties;
 }
 
 void ConnectionStatistics::logIncomingPacket(const category::value &category, size_t size) {
-    auto info_entry = new StatisticEntry{};
-    info_entry->timestamp = system_clock::now();
-    info_entry->size = uint16_t(size);
+    assert(category >= 0 && category <= 2);
+    this->statistics_second_current.connection_bytes_received[category] += size;
+    this->statistics_second_current.connection_packets_received[category] += 1;
 
-    this->_log_incoming_packet(info_entry, category);
-}
-
-void ConnectionStatistics::_log_incoming_packet(ts::stats::StatisticEntry *info_entry, int8_t index) {
-    if(index >= 0 && index <= 3) {
-        this->connection_packets_received[index] ++;
-        this->connection_bytes_received[index] += info_entry->size;
-    }
-    this->connection_packets_received[0] ++;
-    this->connection_bytes_received[0] += info_entry->size;
-
-    if(this->_measure_bandwidths) {
-        auto lock_count = info_entry->use_count++;
-        assert(lock_count >= 0);
-        (void) lock_count;
-
-        lock_guard lock(this->history_lock_incoming);
-        this->history_incoming.push_back(info_entry);
-    }
     if(this->handle)
-        this->handle->_log_incoming_packet(info_entry, index);
+        this->handle->logIncomingPacket(category, size);
 }
 
 void ConnectionStatistics::logOutgoingPacket(const category::value &category, size_t size) {
-    auto info_entry = new StatisticEntry{};
-    info_entry->timestamp = system_clock::now();
-    info_entry->size = uint16_t(size);
+    assert(category >= 0 && category <= 2);
+    this->statistics_second_current.connection_bytes_sent[category] += size;
+    this->statistics_second_current.connection_packets_sent[category] += 1;
 
-    this->_log_outgoing_packet(info_entry, category);
-}
-
-
-void ConnectionStatistics::_log_outgoing_packet(ts::stats::StatisticEntry *info_entry, int8_t index) {
-    if(index >= 0 && index <= 3) {
-        this->connection_packets_sent[index] ++;
-        this->connection_bytes_sent[index] += info_entry->size;
-    }
-    this->connection_packets_sent[0] ++;
-    this->connection_bytes_sent[0] += info_entry->size;
-
-    if(this->_measure_bandwidths) {
-        auto lock_count = info_entry->use_count++;
-        assert(lock_count >= 0);
-        (void) lock_count;
-
-        lock_guard lock(this->history_lock_outgoing);
-        this->history_outgoing.push_back(info_entry);
-    }
     if(this->handle)
-        this->handle->_log_outgoing_packet(info_entry, index);
+        this->handle->logOutgoingPacket(category, size);
 }
 
 /* file transfer */
-void ConnectionStatistics::logFileTransferIn(uint64_t bytes) {
-    auto info_entry = new StatisticEntry{};
-    info_entry->timestamp = system_clock::now();
-    info_entry->size = bytes;
-
-    this->_log_incoming_file_packet(info_entry);
-}
-
-void ConnectionStatistics::_log_incoming_file_packet(ts::stats::StatisticEntry *info_entry) {
-    this->file_bytes_received += info_entry->size;
-
-    if(this->_measure_bandwidths) {
-        auto lock_count = info_entry->use_count++;
-        assert(lock_count >= 0);
-        (void) lock_count;
-
-        lock_guard lock(this->history_lock_incoming);
-        this->history_file_incoming.push_back(info_entry);
-    }
+void ConnectionStatistics::logFileTransferIn(uint32_t bytes) {
+    this->statistics_second_current.file_bytes_received += bytes;
+    this->file_bytes_received += bytes;
 
     if(this->handle)
-        this->handle->_log_incoming_file_packet(info_entry);
+        this->handle->logFileTransferIn(bytes);
 }
 
-void ConnectionStatistics::logFileTransferOut(uint64_t bytes) {
-    auto info_entry = new StatisticEntry{};
-    info_entry->timestamp = system_clock::now();
-    info_entry->size = bytes;
-
-    this->_log_outgoing_file_packet(info_entry);
-}
-
-void ConnectionStatistics::_log_outgoing_file_packet(ts::stats::StatisticEntry *info_entry) {
-    this->file_bytes_sent += info_entry->size;
-
-    if(this->_measure_bandwidths) {
-        auto lock_count = info_entry->use_count++;
-        assert(lock_count >= 0);
-        (void) lock_count;
-
-        lock_guard lock(this->history_lock_outgoing);
-        this->history_file_outgoing.push_back(info_entry);
-    }
+void ConnectionStatistics::logFileTransferOut(uint32_t bytes) {
+    this->statistics_second_current.file_bytes_sent += bytes;
+    this->file_bytes_sent += bytes;
 
     if(this->handle)
-        this->handle->_log_outgoing_file_packet(info_entry);
+        this->handle->logFileTransferOut(bytes);
 }
 
 void ConnectionStatistics::tick() {
-    StatisticEntry* entry;
-    {
-        auto timeout_min = system_clock::now() - minutes(1);
+    auto now = std::chrono::system_clock::now();
+    auto time_difference = this->last_second_tick.time_since_epoch().count() > 0 ? now - this->last_second_tick : std::chrono::seconds{1};
+    if(time_difference >= std::chrono::seconds{1}) {
+        BandwidthEntry<uint32_t> current{};
+        current.atomic_exchange(this->statistics_second_current);
 
-        lock_guard lock(this->history_lock_incoming);
+        auto period_ms = std::chrono::floor<std::chrono::milliseconds>(time_difference).count();
+        auto current_normalized = current.mul<long double>(1000.0 / period_ms);
 
-        while(!this->history_incoming.empty() && (entry = this->history_incoming[0])->timestamp < timeout_min) {
-            if(entry->use_count.fetch_sub(1) == 1)
-                delete entry;
+        this->statistics_second = this->statistics_second.mul<long double>(.2) + current_normalized.mul<long double>(.8);
+        this->total_statistics += current;
 
-            this->history_incoming.pop_front();
-        }
+        auto current_second = std::chrono::floor<std::chrono::seconds>(now.time_since_epoch()).count();
+        if(statistics_minute_offset == 0)
+            statistics_minute_offset = current_second;
 
-        while(!this->history_file_incoming.empty() && (entry = this->history_file_incoming[0])->timestamp < timeout_min) {
-            if(entry->use_count.fetch_sub(1) == 1)
-                delete entry;
-
-            this->history_file_incoming.pop_front();
-        }
-    }
-    {
-        auto timeout_min = system_clock::now() - minutes(1);
-        lock_guard lock(this->history_lock_outgoing);
-
-        while(!this->history_outgoing.empty() && (entry = this->history_outgoing[0])->timestamp < timeout_min) {
-            if(entry->use_count.fetch_sub(1) == 1)
-                delete entry;
-
-            this->history_outgoing.pop_front();
-        }
-
-        while(!this->history_file_outgoing.empty() && (entry = this->history_file_outgoing[0])->timestamp < timeout_min) {
-            if(entry->use_count.fetch_sub(1) == 1)
-                delete entry;
-
-            this->history_file_outgoing.pop_front();
-        }
-    }
-
-    if(this->properties) {
-        auto& _properties = *this->properties;
-#define M(type, index) \
-    _properties[property::CONNECTION_BYTES_SENT_ ##type] = (uint64_t) this->connection_bytes_sent[index]; \
-    _properties[property::CONNECTION_PACKETS_SENT_ ##type] = (uint64_t) this->connection_packets_sent[index]; \
-    _properties[property::CONNECTION_BYTES_RECEIVED_ ##type] = (uint64_t) this->connection_bytes_received[index]; \
-    _properties[property::CONNECTION_PACKETS_RECEIVED_ ##type] = (uint64_t) this->connection_packets_received[index]; \
-
-        M(TOTAL, 0);
-        M(CONTROL, 1);
-        M(KEEPALIVE, 2);
-        M(SPEECH, 3);
-
-        _properties[property::CONNECTION_FILETRANSFER_BYTES_RECEIVED_TOTAL] = (uint64_t) this->file_bytes_received;
-        _properties[property::CONNECTION_FILETRANSFER_BYTES_SENT_TOTAL] = (uint64_t) this->file_bytes_sent;
-
-        _properties[property::CONNECTION_FILETRANSFER_BYTES_RECEIVED_TOTAL] = (uint64_t) this->file_bytes_received;
-        _properties[property::CONNECTION_FILETRANSFER_BYTES_SENT_TOTAL] = (uint64_t) this->file_bytes_sent;
+        /* fill all "lost" with the current bandwidth as well */
+        while(statistics_minute_offset <= current_second)
+            this->statistics_minute[statistics_minute_offset++ % this->statistics_minute.size()] = current_normalized;
+        this->last_second_tick = now;
     }
 }
-
-DataSummery ConnectionStatistics::dataReport() {
-    DataSummery report{};
-    auto minTimeout = system_clock::now() - seconds(1);
-
-
-    {
-        lock_guard lock(this->history_lock_incoming);
-
-        for(const auto& elm : this->history_incoming){
-            if(elm->timestamp >= minTimeout) {
-                report.recv_second += elm->size;
-            }
-
-            report.recv_minute += elm->size;
-        }
-
-        for(const auto& elm : this->history_file_incoming) {
-            report.file_recv += elm->size;
-        }
-    }
-
-    {
-        lock_guard lock(this->history_lock_outgoing);
-
-        for(const auto& elm : this->history_outgoing){
-            if(elm->timestamp >= minTimeout) {
-                report.send_second += elm->size;
-            }
-
-            report.send_minute += elm->size;
-        }
-
-        for(const auto& elm : this->history_file_outgoing) {
-            report.file_send += elm->size;
-        }
-    }
-
-    report.recv_minute /= 60;
-    report.send_minute /= 60;
-    return report;
+BandwidthEntry<uint32_t> ConnectionStatistics::minute_stats() const {
+    BandwidthEntry<uint32_t> result{};
+    for(const auto& second : this->statistics_minute)
+        result += second;
+    return result.mul<uint32_t>(1. / (double) this->statistics_minute.size());
 }
 
-FullReport ConnectionStatistics::full_report() {
-    FullReport report{};
+FileTransferStatistics ConnectionStatistics::file_stats() {
+    FileTransferStatistics result{};
 
-    for(size_t index = 0 ; index < 4; index++) {
-        report.connection_bytes_sent[index] = (uint64_t) this->connection_bytes_sent[index];
-        report.connection_packets_sent[index] = (uint64_t) this->connection_packets_sent[index];
-        report.connection_bytes_received[index] = (uint64_t) this->connection_bytes_received[index];
-        report.connection_packets_received[index] = (uint64_t) this->connection_packets_received[index];
-    }
+    result.bytes_received = this->file_bytes_received;
+    result.bytes_sent = this->file_bytes_sent;
 
-    report.file_bytes_sent = this->file_bytes_sent;
-    report.file_bytes_received = this->file_bytes_received;
-
-    return report;
+    return result;
 }
 
 std::pair<uint64_t, uint64_t> ConnectionStatistics::mark_file_bytes() {
     std::pair<uint64_t, uint64_t> result;
 
     {
-        lock_guard lock(this->history_lock_incoming);
         if(this->mark_file_bytes_received < this->file_bytes_received)
             result.second = this->file_bytes_received - this->mark_file_bytes_received;
         this->mark_file_bytes_received = (uint64_t) this->file_bytes_received;
     }
 
     {
-
-        lock_guard lock(this->history_lock_outgoing);
-
         if(this->mark_file_bytes_sent < this->file_bytes_sent)
             result.first = this->file_bytes_sent - this->mark_file_bytes_sent;
         this->mark_file_bytes_sent = (uint64_t) this->file_bytes_sent;

server/src/ConnectionStatistics.h

@@ -11,41 +11,97 @@ namespace ts {
     }
 
     namespace stats {
-        struct StatisticEntry {
-            std::atomic<int8_t> use_count{0};
-            std::chrono::time_point<std::chrono::system_clock> timestamp;
-            uint16_t size = 0;
+        template <typename value_t>
+        struct BandwidthEntry {
+            std::array<value_t, 3> connection_packets_sent{};
+            std::array<value_t, 3> connection_bytes_sent{};
+            std::array<value_t, 3> connection_packets_received{};
+            std::array<value_t, 3> connection_bytes_received{};
+
+            value_t file_bytes_sent{0};
+            value_t file_bytes_received{0};
+
+            template <typename other_type>
+            inline BandwidthEntry& operator=(const BandwidthEntry<other_type>& other) {
+                for(size_t index{0}; index < this->connection_packets_sent.size(); index++)
+                    this->connection_packets_sent[index] = other.connection_packets_sent[index];
+                for(size_t index{0}; index < this->connection_bytes_sent.size(); index++)
+                    this->connection_bytes_sent[index] = other.connection_bytes_sent[index];
+                for(size_t index{0}; index < this->connection_packets_received.size(); index++)
+                    this->connection_packets_received[index] = other.connection_packets_received[index];
+                for(size_t index{0}; index < this->connection_bytes_received.size(); index++)
+                    this->connection_bytes_received[index] = other.connection_bytes_received[index];
+
+                this->file_bytes_sent = other.file_bytes_sent;
+                this->file_bytes_received = other.file_bytes_received;
+                return *this;
+            }
+
+            template <typename target_t>
+            inline BandwidthEntry<target_t> mul(double factor) const {
+                BandwidthEntry<target_t> result{};
+                result = *this;
+                for(auto& val : result.connection_packets_sent) val *= factor;
+                for(auto& val : result.connection_bytes_sent) val *= factor;
+                for(auto& val : result.connection_packets_received) val *= factor;
+                for(auto& val : result.connection_bytes_received) val *= factor;
+
+                result.file_bytes_sent *= factor;
+                result.file_bytes_received *= factor;
+                return result;
+            }
+
+            template <typename other_type>
+            inline BandwidthEntry& operator+=(const BandwidthEntry<other_type>& other) {
+                for(size_t index{0}; index < this->connection_packets_sent.size(); index++)
+                    this->connection_packets_sent[index] += other.connection_packets_sent[index];
+                for(size_t index{0}; index < this->connection_bytes_sent.size(); index++)
+                    this->connection_bytes_sent[index] += other.connection_bytes_sent[index];
+                for(size_t index{0}; index < this->connection_packets_received.size(); index++)
+                    this->connection_packets_received[index] += other.connection_packets_received[index];
+                for(size_t index{0}; index < this->connection_bytes_received.size(); index++)
+                    this->connection_bytes_received[index] += other.connection_bytes_received[index];
+
+                this->file_bytes_sent += other.file_bytes_sent;
+                this->file_bytes_received += other.file_bytes_received;
+                return *this;
+            }
+
+            template <typename other_type>
+            inline BandwidthEntry operator+(const BandwidthEntry<other_type>& other) {
+                return BandwidthEntry{*this} += other;
+            }
+
+            template <typename atomic_t>
+            inline void atomic_exchange(BandwidthEntry<std::atomic<atomic_t>>& source) {
+                for(size_t index{0}; index < this->connection_packets_sent.size(); index++)
+                    this->connection_packets_sent[index] = source.connection_packets_sent[index].exchange(0);
+                for(size_t index{0}; index < this->connection_bytes_sent.size(); index++)
+                    this->connection_bytes_sent[index] = source.connection_bytes_sent[index].exchange(0);
+                for(size_t index{0}; index < this->connection_packets_received.size(); index++)
+                    this->connection_packets_received[index] = source.connection_packets_received[index].exchange(0);
+                for(size_t index{0}; index < this->connection_bytes_received.size(); index++)
+                    this->connection_bytes_received[index] = source.connection_bytes_received[index].exchange(0);
+
+                this->file_bytes_sent = source.file_bytes_sent.exchange(0);
+                this->file_bytes_received = source.file_bytes_received.exchange(0);
+            }
         };
 
-        struct DataSummery {
-            uint32_t send_minute;
-            uint32_t send_second;
-
-            uint32_t recv_minute;
-            uint32_t recv_second;
-
-            uint32_t file_recv;
-            uint32_t file_send;
-        };
-
-        struct FullReport {
-            uint64_t connection_packets_sent[4]{0, 0, 0, 0};
-            uint64_t connection_bytes_sent[4]{0, 0, 0, 0};
-            uint64_t connection_packets_received[4]{0, 0, 0, 0};
-            uint64_t connection_bytes_received[4]{0, 0, 0, 0};
-
-            uint64_t file_bytes_sent = 0;
-            uint64_t file_bytes_received = 0;
+        struct FileTransferStatistics {
+            uint64_t bytes_received{0};
+            uint64_t bytes_sent{0};
         };
 
         class ConnectionStatistics {
             public:
                 struct category {
+                    /* Only three categories. Map unknown to category 0 */
                     enum value {
                         COMMAND,
-                        ACK,
+                        KEEP_ALIVE,
                         VOICE,
-                        UNKNOWN
+                        UNKNOWN = COMMAND
                     };
 
                     constexpr static std::array<category::value, 16> lookup_table{
@@ -53,10 +109,10 @@ namespace ts {
                             VOICE, /* VoiceWhisper */
                             COMMAND, /* Command */
                             COMMAND, /* CommandLow */
-                            ACK, /* Ping */
-                            ACK, /* Pong */
-                            ACK, /* Ack */
-                            ACK, /* AckLow */
+                            KEEP_ALIVE, /* Ping */
+                            KEEP_ALIVE, /* Pong */
+                            COMMAND, /* Ack */
+                            COMMAND, /* AckLow */
                             COMMAND, /* */
 
                             UNKNOWN,
@@ -76,58 +132,38 @@ namespace ts {
                         return from_type(type.type());
                     }
                 };
-                explicit ConnectionStatistics(const std::shared_ptr<ConnectionStatistics>& /* root */, bool /* spawn properties */);
+                explicit ConnectionStatistics(std::shared_ptr<ConnectionStatistics>  /* root */);
                 ~ConnectionStatistics();
 
-                std::shared_ptr<Properties> statistics();
-
-                inline void logIncomingPacket(const protocol::ClientPacket& packet) { this->logIncomingPacket(category::from_type(packet.type()), packet.length()); }
                 void logIncomingPacket(const category::value& /* category */, size_t /* length */);
-                inline void logOutgoingPacket(const protocol::ServerPacket& packet) { this->logOutgoingPacket(category::from_type(packet.type()), packet.length()); }
                 void logOutgoingPacket(const category::value& /* category */, size_t /* length */);
-                void logFileTransferIn(uint64_t);
-                void logFileTransferOut(uint64_t);
+                void logFileTransferIn(uint32_t);
+                void logFileTransferOut(uint32_t);
 
                 void tick();
 
-                DataSummery dataReport();
-                FullReport full_report();
+                [[nodiscard]] inline const BandwidthEntry<uint64_t>& total_stats() const { return this->total_statistics; }
+                [[nodiscard]] inline BandwidthEntry<uint32_t> second_stats() const { return this->statistics_second; }
+                [[nodiscard]] BandwidthEntry<uint32_t> minute_stats() const;
 
+                FileTransferStatistics file_stats();
                 std::pair<uint64_t, uint64_t> mark_file_bytes();
-
-                inline bool measure_bandwidths() { return this->_measure_bandwidths; }
-                void measure_bandwidths(bool flag) { this->_measure_bandwidths = flag; }
-
-                inline bool has_properties() { return !!this->properties; }
             private:
-                bool _measure_bandwidths = true;
                 std::shared_ptr<ConnectionStatistics> handle;
-                std::shared_ptr<Properties> properties;
 
+                BandwidthEntry<uint64_t> total_statistics{};
 
-                std::atomic<uint64_t> connection_packets_sent[4]{0, 0, 0, 0};
-                std::atomic<uint64_t> connection_bytes_sent[4]{0, 0, 0, 0};
-                std::atomic<uint64_t> connection_packets_received[4]{0, 0, 0, 0};
-                std::atomic<uint64_t> connection_bytes_received[4]{0, 0, 0, 0};
+                BandwidthEntry<std::atomic<uint64_t>> statistics_second_current{};
+                BandwidthEntry<uint32_t> statistics_second{}; /* will be updated every second by the stats from the "current_second" */
+                std::array<BandwidthEntry<uint32_t>, 60> statistics_minute{};
+                uint32_t statistics_minute_offset{0}; /* pointing to the upcoming minute */
+                std::chrono::system_clock::time_point last_second_tick{};
 
-                std::atomic<uint64_t> file_bytes_sent = 0;
-                std::atomic<uint64_t> file_bytes_received = 0;
+                std::atomic<uint64_t> file_bytes_sent{0};
+                std::atomic<uint64_t> file_bytes_received{0};
 
-                std::atomic<uint64_t> mark_file_bytes_sent = 0;
-                std::atomic<uint64_t> mark_file_bytes_received = 0;
-
-                spin_lock history_lock_outgoing;
-                spin_lock history_lock_incoming;
-                std::deque<StatisticEntry*> history_file_incoming{};
-                std::deque<StatisticEntry*> history_file_outgoing{};
-                std::deque<StatisticEntry*> history_incoming{};
-                std::deque<StatisticEntry*> history_outgoing{};
-
-                void _log_incoming_packet(StatisticEntry */* statistics */, int8_t /* type index */);
-                void _log_outgoing_packet(StatisticEntry* /* statistics */, int8_t /* type index */);
-
-                void _log_incoming_file_packet(StatisticEntry */* statistics */);
-                void _log_outgoing_file_packet(StatisticEntry* /* statistics */);
+                uint64_t mark_file_bytes_sent{0};
+                uint64_t mark_file_bytes_received{0};
         };
     }
 }

server/src/DatabaseHelper.cpp

@@ -37,7 +37,7 @@ void DatabaseHelper::tick() {
     {
         threads::MutexLock l(this->propsLock);
         auto pcpy = this->cachedProperties;
-        for(const auto& mgr : pcpy){
+        for(const auto& mgr : pcpy) {
             if(mgr->ownLock && system_clock::now() - mgr->lastAccess > minutes(5))
                 mgr->ownLock.reset();
             if(mgr->properties.expired()) {
@@ -159,7 +159,12 @@ void DatabaseHelper::deleteClient(const std::shared_ptr<VirtualServer>& server,
     //TODO delete complains
 }
 
-inline sql::result load_permissions_v2(const std::shared_ptr<VirtualServer>& server, v2::PermissionManager* manager, sql::command& command, bool test_channel /* only used for client permissions (client channel permissions) */) {
+inline sql::result load_permissions_v2(
+        const std::shared_ptr<VirtualServer>& server,
+        v2::PermissionManager* manager,
+        sql::command& command,
+        bool test_channel, /* only used for client permissions (client channel permissions) */
+        bool is_channel) {
     auto start = system_clock::now();
 
     auto server_id = server ? server->getServerId() : 0;
@@ -213,7 +218,7 @@ inline sql::result load_permissions_v2(const std::shared_ptr<VirtualServer>& ser
             return 0;
         }
 
-        if(channel_id == 0)
+        if(channel_id == 0 || is_channel)
             manager->load_permission(key, {value, granted}, skipped, negated, value != permNotGranted, granted != permNotGranted);
         else
             manager->load_permission(key, {value, granted}, channel_id, skipped, negated, value != permNotGranted, granted != permNotGranted);
@@ -282,7 +287,7 @@ std::shared_ptr<v2::PermissionManager> DatabaseHelper::loadClientPermissionManag
                                     variable{":serverId", server ? server->getServerId() : 0},
                                     variable{":type", permission::SQL_PERM_USER},
                                     variable{":id", cldbid});
-        LOG_SQL_CMD(load_permissions_v2(server, permission_manager.get(), command, true));
+        LOG_SQL_CMD(load_permissions_v2(server, permission_manager.get(), command, true, false));
     }
 
 
@@ -364,7 +369,7 @@ std::shared_ptr<permission::v2::PermissionManager> DatabaseHelper::loadGroupPerm
                                 variable{":serverId", server ? server->getServerId() : 0},
                                 variable{":type", permission::SQL_PERM_GROUP},
                                 variable{":id", group_id});
-    LOG_SQL_CMD(load_permissions_v2(server, result.get(), command, false));
+    LOG_SQL_CMD(load_permissions_v2(server, result.get(), command, false, false));
     return result;
 }
 
@@ -436,7 +441,7 @@ std::shared_ptr<permission::v2::PermissionManager> DatabaseHelper::loadPlaylistP
                                 variable{":serverId", server ? server->getServerId() : 0},
                                 variable{":type", permission::SQL_PERM_PLAYLIST},
                                 variable{":id", playlist_id});
-    LOG_SQL_CMD(load_permissions_v2(server, result.get(), command, false));
+    LOG_SQL_CMD(load_permissions_v2(server, result.get(), command, false, false));
     return result;
 }
 
@@ -502,7 +507,7 @@ std::shared_ptr<permission::v2::PermissionManager> DatabaseHelper::loadChannelPe
                                 variable{":chid", channel},
                                 variable{":id", 0},
                                 variable{":type", permission::SQL_PERM_CHANNEL});
-    LOG_SQL_CMD(load_permissions_v2(server, result.get(), command, false));
+    LOG_SQL_CMD(load_permissions_v2(server, result.get(), command, false, true));
     return result;
 }
 
@@ -555,39 +560,44 @@ std::shared_ptr<Properties> DatabaseHelper::default_properties_client(std::share
     return properties;
 }
 
+std::mutex DatabaseHelper::database_id_mutex{};
+
 bool DatabaseHelper::assignDatabaseId(sql::SqlManager *sql, ServerId id, std::shared_ptr<DataClient> cl) {
     cl->loadDataForCurrentServer();
     if(cl->getClientDatabaseId() == 0){ //Client does not exist
-        ClientDbId cldbid = 0;
+        ClientDbId new_client_database_id{0};
         auto res = sql::command(sql, "SELECT `cldbid` FROM `clients` WHERE `serverId` = 0 AND `clientUid` = :cluid", variable{":cluid", cl->getUid()}).query([](ClientDbId* ptr, int length, char** values, char** names){
             *ptr = static_cast<ClientDbId>(stoll(values[0]));
             return 0;
-        }, &cldbid);
+        }, &new_client_database_id);
         auto pf = LOG_SQL_CMD;
         pf(res);
         if(!res) return false;
 
         auto insertTemplate = sql::model(sql, "INSERT INTO `clients` (`serverId`, `cldbId`,  `clientUid`, `lastName`,`firstConnect`,`lastConnect`, `connections`) VALUES (:serverId, :cldbid, :cluid, :name, :fconnect, :lconnect, :connections)",
-                                         variable{":cluid", cl->getUid()}, variable{":name", cl->getDisplayName()}, variable{":fconnect", duration_cast<seconds>(system_clock::now().time_since_epoch()).count()}, variable{":lconnect", 0}, variable{":connections", 0});
-        if(cldbid == 0){ //Completly new user
-            res = sql::command(sql, "SELECT `cldbid` FROM `clients` WHERE `serverId` = 0 ORDER BY `cldbid` DESC LIMIT 1").query([](ClientDbId* ptr, int length, char** values, char** names){
-                *ptr = static_cast<ClientDbId>(stoll(values[0]));
-                return 0;
-            }, &cldbid);
-            pf(res);
+                                         variable{":cluid", cl->getUid()}, variable{":name", cl->getDisplayName()},
+                                         variable{":fconnect", duration_cast<seconds>(system_clock::now().time_since_epoch()).count()}, variable{":lconnect", 0},
+                                         variable{":connections", 0});
+        if(new_client_database_id == 0) { /* we've a completely new user */
+            std::lock_guard db_id_lock{DatabaseHelper::database_id_mutex};
+            res = sql::command(sql, "SELECT `cldbid` FROM `clients` WHERE `serverId` = 0 ORDER BY `cldbid` DESC LIMIT 1").query([&](int length, std::string* values, std::string* names) {
+                assert(length == 1);
+                new_client_database_id = (ClientDbId) stoll(values[0]);
+            });
+            LOG_SQL_CMD(res);
             if(!res) return false;
 
-            cldbid += 1;
-            res = insertTemplate.command().values(variable{":serverId", 0}, variable{":cldbid", cldbid}).execute(); //Insert global
-            pf(res);
+            new_client_database_id += 1;
+            res = insertTemplate.command().values(variable{":serverId", 0}, variable{":cldbid", new_client_database_id}).execute(); //Insert global
+            LOG_SQL_CMD(res);
             if(!res) return false;
-            debugMessage(id, "Having new instance user on server {}. (Database ID: {} Name: {})", id, cldbid, cl->getDisplayName());
+            debugMessage(LOG_INSTANCE, "Registered a new client. Unique id: {}, First server: {}, Database ID: {}", cl->getUid(), id, new_client_database_id);
         } else {
-            debugMessage(id, "Having new server user on server {}. (Database ID: {} Name: {})", id, cldbid, cl->getDisplayName());
+            debugMessage(id, "Having new client, which is already known on this instance. Unique id: {}, First server: {}, Database ID: {}", cl->getUid(), id, new_client_database_id);
         }
 
         if(id != 0){ //Else already inserted
-            res = insertTemplate.command().values(variable{":serverId", id}, variable{":cldbid", cldbid}).execute();
+            res = insertTemplate.command().values(variable{":serverId", id}, variable{":cldbid", new_client_database_id}).execute();
             pf(res);
             if(!res) return false;
         }
@@ -595,7 +605,7 @@ bool DatabaseHelper::assignDatabaseId(sql::SqlManager *sql, ServerId id, std::sh
         return assignDatabaseId(sql, id, cl);
     }
 
-    logTrace(id, "Loaded client from database. Database id: {} Unique id: {}", cl->getClientDatabaseId(), cl->getUid());
+    logTrace(id, "Loaded client successfully from database. Database id: {} Unique id: {}", cl->getClientDatabaseId(), cl->getUid());
     return true;
 }
 
@@ -617,8 +627,8 @@ inline sql::result load_properties(ServerId sid, deque<unique_ptr<FastPropertyEn
             }
         }
 
-        const auto &info = property::impl::info_key(type, key);
-        if(info->name == "undefined") {
+        const auto &info = property::find(type, key);
+        if(info.name == "undefined") {
             logError(sid, "Found unknown property in database! ({})", key);
             return 0;
         }
@@ -630,9 +640,9 @@ inline sql::result load_properties(ServerId sid, deque<unique_ptr<FastPropertyEn
         prop.setDbReference(true);
         */
 
-        auto data = make_unique<FastPropertyEntry>();
+        auto data = std::make_unique<FastPropertyEntry>();
+        data->type = &info;
         data->value = value;
-        data->type = info;
         properties.push_back(move(data));
         return 0;
     });
@@ -705,7 +715,7 @@ std::shared_ptr<Properties> DatabaseHelper::loadServerProperties(const std::shar
             sql = "INSERT INTO `properties` (`serverId`, `type`, `id`, `key`, `value`) VALUES (:sid, :type, :id, :key, :value)";
         }
 
-        logTrace(serverId, "Updating server property: " + prop.type().name + ". New value: " + prop.value() + ". Query: " + sql);
+        logTrace(serverId, "Updating server property: " + std::string{prop.type().name} + ". New value: " + prop.value() + ". Query: " + sql);
         sql::command(this->sql, sql,
                      variable{":sid", serverId},
                      variable{":type", property::PropertyType::PROP_TYPE_SERVER},
@@ -925,7 +935,7 @@ std::shared_ptr<Properties> DatabaseHelper::loadClientProperties(const std::shar
 
         if(!prop.isModified()) return;
         if((prop.type().flags & property::FLAG_SAVE) == 0 && (type != ClientType::CLIENT_MUSIC || (prop.type().flags & property::FLAG_SAVE_MUSIC) == 0)) {
-            logTrace(server ? server->getServerId() : 0, "[Property] Not saving property '" + prop.type().name + "', changed for " + to_string(cldbid) + " (New value: " + prop.value() + ")");
+            logTrace(server ? server->getServerId() : 0, "[Property] Not saving property '" + std::string{prop.type().name} + "', changed for " + to_string(cldbid) + " (New value: " + prop.value() + ")");
             return;
         }
         if(!prop.get_handle()) return;
@@ -940,7 +950,7 @@ std::shared_ptr<Properties> DatabaseHelper::loadClientProperties(const std::shar
             prop.setDbReference(true);
             sql = "INSERT INTO `properties` (`serverId`, `type`, `id`, `key`, `value`) VALUES (:serverId, :type, :id, :key, :value)";
         }
-        logTrace(server ? server->getServerId() : 0, "[Property] Changed property in db key: " + prop.type().name + " value: " + prop.value());
+        logTrace(server ? server->getServerId() : 0, "[Property] Changed property in db key: " + std::string{prop.type().name} + " value: " + prop.value());
         sql::command(this->sql, sql,
                 variable{":serverId", server ? server->getServerId() : 0},
                 variable{":type", prop.type().type_property},
@@ -965,7 +975,7 @@ std::shared_ptr<Properties> DatabaseHelper::loadClientProperties(const std::shar
         else if(prop.type() == property::CLIENT_LASTCONNECTED)
             query = "UPDATE `clients` SET `lastConnect` = :value WHERE `serverId` = :serverId AND `cldbid` = :cldbid";
         if(query.empty()) return;
-        debugMessage(server ? server->getServerId() : 0, "[Property] Changing client property '" + prop.type().name + "' for " + to_string(cldbid) + " (New value: " + prop.value() + ", SQL: " + query + ")");
+        debugMessage(server ? server->getServerId() : 0, "[Property] Changing client property '" + std::string{prop.type().name} + "' for " + to_string(cldbid) + " (New value: " + prop.value() + ", SQL: " + query + ")");
         sql::command(this->sql, query, variable{":serverId", server ? server->getServerId() : 0}, variable{":cldbid", cldbid}, variable{":value", prop.value()}).executeLater().waitAndGetLater(LOG_SQL_CMD, {1, "future failed"});
     });
 
@@ -1119,8 +1129,8 @@ void DatabaseHelper::loadStartupPropertyCache() {
             }
         }
 
-        auto info = property::impl::info_key(type, key);
-        if(info == property::PropertyDescription::unknown) {
+        const auto& info = property::find(type, key);
+        if(info.is_undefined()) {
             logError(serverId, "Invalid property ({} | {})", key, type);
             return 0;
         }
@@ -1145,7 +1155,7 @@ void DatabaseHelper::loadStartupPropertyCache() {
         }
 
         auto entry = make_unique<StartupPropertyEntry>();
-        entry->info = info;
+        entry->info = &info;
         entry->value = value;
         entry->id = id;
         entry->type = type;

server/src/DatabaseHelper.h

@@ -57,8 +57,8 @@ namespace ts {
 
         struct StartupPropertyEntry {
             property::PropertyType type = property::PropertyType::PROP_TYPE_UNKNOWN;
-            uint64_t id = 0;
-            std::shared_ptr<property::PropertyDescription> info = property::PropertyDescription::unknown;
+            uint64_t id{0};
+            const property::PropertyDescription* info{&property::undefined_property_description};
             std::string value;
         };
 
@@ -70,7 +70,7 @@ namespace ts {
         };
 
         struct FastPropertyEntry {
-            std::shared_ptr<property::PropertyDescription> type;
+            const property::PropertyDescription* type;
             std::string value;
         };
 
@@ -78,6 +78,7 @@ namespace ts {
             public:
                 static std::shared_ptr<Properties> default_properties_client(std::shared_ptr<Properties> /* properties */, ClientType /* type */);
                 static bool assignDatabaseId(sql::SqlManager *, ServerId id, std::shared_ptr<DataClient>);
+                static std::mutex database_id_mutex;
 
                 explicit DatabaseHelper(sql::SqlManager*);
                 ~DatabaseHelper();

server/src/Group.cpp

@@ -6,7 +6,7 @@
 #include "VirtualServer.h"
 #include "src/client/ConnectedClient.h"
 #include "InstanceHandler.h"
-#include "src/server/file/FileServer.h"
+#include "src/server/file/LocalFileServer.h"
 
 using namespace std;
 using namespace std::chrono;
@@ -93,6 +93,7 @@ GroupManager::GroupManager(const shared_ptr<VirtualServer> &server, sql::SqlMana
 GroupManager::~GroupManager() {}
 
 bool GroupManager::loadGroupFormDatabase(GroupId id) {
+    std::lock_guard glock{this->group_lock};
     if(id == 0){
         this->groups.clear();
 
@@ -116,8 +117,13 @@ bool GroupManager::loadGroupFormDatabase(GroupId id) {
 
 std::vector<std::shared_ptr<Group>> GroupManager::availableGroups(bool root) {
     std::vector<std::shared_ptr<Group>> response;
-    for(const auto& group : this->groups)
-        response.push_back(group);
+
+    {
+        std::lock_guard glock{this->group_lock};
+        for(const auto& group : this->groups)
+            response.push_back(group);
+    }
+
     if(root && this->root){
         auto elm = this->root->availableGroups();
         for(const auto& e : elm)
@@ -128,9 +134,14 @@ std::vector<std::shared_ptr<Group>> GroupManager::availableGroups(bool root) {
 
 std::vector<std::shared_ptr<Group>> GroupManager::availableServerGroups(bool root){
     std::vector<std::shared_ptr<Group>> response;
-    for(const auto& group : this->groups)
-        if(group->target() == GroupTarget::GROUPTARGET_SERVER)
-            response.push_back(group);
+
+    {
+        std::lock_guard glock{this->group_lock};
+        for(const auto& group : this->groups)
+            if(group->target() == GroupTarget::GROUPTARGET_SERVER)
+                response.push_back(group);
+    }
+
     if(root && this->root){
         auto elm = this->root->availableServerGroups();
         for(const auto& e : elm)
@@ -141,9 +152,12 @@ std::vector<std::shared_ptr<Group>> GroupManager::availableServerGroups(bool roo
 
 std::vector<std::shared_ptr<Group>> GroupManager::availableChannelGroups(bool root) {
     std::vector<std::shared_ptr<Group>> response;
-    for(const auto& group : this->groups)
-        if(group->target() == GroupTarget::GROUPTARGET_CHANNEL)
-            response.push_back(group);
+    {
+        std::lock_guard glock{this->group_lock};
+        for(const auto& group : this->groups)
+            if(group->target() == GroupTarget::GROUPTARGET_CHANNEL)
+                response.push_back(group);
+    }
     if(root && this->root){
         auto elm = this->root->availableChannelGroups(true);
         for(const auto& e : elm)
@@ -167,8 +181,7 @@ int GroupManager::insertGroupFromDb(int count, char **values, char **column) {
             groupId = (GroupType) stoll(values[index]);
         else if(strcmp(column[index], "displayName") == 0)
             targetName = values[index];
-        else if(strcmp(column[index], "serverId") == 0);
-        else cerr << "Invalid group table row " << column[index] << endl;
+        //else cerr << "Invalid group table row " << column[index] << endl;
     }
 
     if((size_t) groupId == 0 || (size_t) target == 0xff || (size_t) type == 0xff || targetName.empty()) {
@@ -237,6 +250,7 @@ void GroupManager::handleChannelDeleted(const ChannelId& channel_id) {
 }
 
 bool GroupManager::isLocalGroup(std::shared_ptr<Group> gr) {
+    std::lock_guard glock{this->group_lock};
     return std::find(this->groups.begin(), this->groups.end(), gr) != this->groups.end();
 }
 
@@ -252,9 +266,12 @@ std::shared_ptr<Group> GroupManager::defaultGroup(GroupTarget type, bool enforce
     auto group = this->findGroupLocal(id);
     if(group || enforce_property) return group;
 
-    for(auto elm : this->groups)
-        if(elm->target() == type)
-            return elm;
+    {
+        std::lock_guard glock{this->group_lock};
+        for(auto elm : this->groups)
+            if(elm->target() == type)
+                return elm;
+    }
 
     return nullptr; //Worst case!
 }
@@ -266,6 +283,7 @@ std::shared_ptr<Group> GroupManager::findGroup(GroupId groupId) {
 }
 
 std::shared_ptr<Group> GroupManager::findGroupLocal(GroupId groupId) {
+    std::lock_guard glock{this->group_lock};
     for(const auto& elm : this->groups)
         if(elm->groupId() == groupId) return elm;
     return nullptr;
@@ -273,8 +291,11 @@ std::shared_ptr<Group> GroupManager::findGroupLocal(GroupId groupId) {
 
 std::vector<std::shared_ptr<Group>> GroupManager::findGroup(GroupTarget target, std::string name) {
     vector<shared_ptr<Group>> res;
-    for(const auto &elm : this->groups)
-        if(elm->name() == name && elm->target() == target) res.push_back(elm);
+    {
+        std::lock_guard glock{this->group_lock};
+        for(const auto &elm : this->groups)
+            if(elm->name() == name && elm->target() == target) res.push_back(elm);
+    }
     if(this->root) {
         auto r = root->findGroup(target, name);
         for(const auto &e : r) res.push_back(e);
@@ -305,6 +326,8 @@ std::shared_ptr<Group> GroupManager::createGroup(GroupTarget target, GroupType t
     std::shared_ptr<Group> group = std::make_shared<Group>(this, target, type, groupId);
     group->properties()[property::GROUP_NAME] = name;
     group->setPermissionManager(serverInstance->databaseHelper()->loadGroupPermissions(this->server.lock(), group->groupId()));
+
+    std::lock_guard glock{this->group_lock};
     this->groups.push_back(group);
     return group;
 }
@@ -394,7 +417,10 @@ bool GroupManager::deleteGroup(std::shared_ptr<Group> group) {
         return false;
     }
 
-    this->groups.erase(std::find(this->groups.begin(), this->groups.end(), group));
+    {
+        std::lock_guard glock{this->group_lock};
+        this->groups.erase(std::find(this->groups.begin(), this->groups.end(), group));
+    }
 
     /* erase the group out of our cache */
     {

server/src/Group.h

@@ -215,7 +215,6 @@ namespace ts {
             bool isClientCached(const ClientDbId& /* client database id */);
             void clearCache();
 
-
             bool isLocalGroup(std::shared_ptr<Group>);
         protected:
             void handleChannelDeleted(const ChannelId& /* channel id */);
@@ -225,7 +224,10 @@ namespace ts {
             ServerId getServerId();
 
             sql::SqlManager* sql;
+
+            std::mutex group_lock{};
             std::vector<std::shared_ptr<Group>> groups;
+
             threads::Mutex cacheLock;
             std::vector<std::shared_ptr<CachedClient>> cachedClients;
 

server/src/InstanceHandler.cpp

@@ -9,7 +9,7 @@
 #include "InstanceHandler.h"
 #include "src/client/InternalClient.h"
 #include "src/server/QueryServer.h"
-#include "src/server/file/FileServer.h"
+#include "src/server/file/LocalFileServer.h"
 #include "SignalHandler.h"
 #include "src/manager/PermissionNameMapper.h"
 #include <ThreadPool/Timer.h>
@@ -41,8 +41,7 @@ extern bool mainThreadActive;
 InstanceHandler::InstanceHandler(SqlDataManager *sql) : sql(sql) {
     serverInstance = this;
     this->tick_manager = make_shared<threads::Scheduler>(config::threads::ticking, "tick task ");
-    this->statistics = make_shared<stats::ConnectionStatistics>(nullptr, true);
-    this->statistics->measure_bandwidths(true);
+    this->statistics = make_shared<stats::ConnectionStatistics>(nullptr);
 
     std::string error_message{};
     this->license_service_ = std::make_shared<license::LicenseService>();
@@ -70,8 +69,8 @@ InstanceHandler::InstanceHandler(SqlDataManager *sql) : sql(sql) {
                     }
                 }
 
-                const auto &info = property::impl::info<property::InstanceProperties>(key);
-                if(*info == property::SERVERINSTANCE_UNDEFINED) {
+                const auto &info = property::find<property::InstanceProperties>(key);
+                if(info == property::SERVERINSTANCE_UNDEFINED) {
                     logError(0, "Got an unknown instance property " + key);
                     return 0;
                 }
@@ -282,19 +281,19 @@ bool InstanceHandler::startInstance() {
     }
 
     this->loadWebCertificate();
-    fileServer = new ts::server::FileServer();
+    fileServer = new ts::server::LocalFileServer();
     {
         auto bindings_string = this->properties()[property::SERVERINSTANCE_FILETRANSFER_HOST].as<string>();
         auto port = this->properties()[property::SERVERINSTANCE_FILETRANSFER_PORT].as<uint16_t>();
         auto ft_bindings = net::resolve_bindings(bindings_string, port);
-        deque<shared_ptr<FileServer::Binding>> bindings;
+        deque<shared_ptr<LocalFileServer::Binding>> bindings;
 
         for(auto& binding : ft_bindings) {
             if(!get<2>(binding).empty()) {
                 logError(LOG_FT, "Failed to resolve binding for {}: {}", get<0>(binding), get<2>(binding));
                 continue;
             }
-            auto entry = make_shared<FileServer::Binding>();
+            auto entry = make_shared<LocalFileServer::Binding>();
             memcpy(&entry->address, &get<1>(binding), sizeof(sockaddr_storage));
 
             entry->file_descriptor = -1;
@@ -414,7 +413,7 @@ FwIDAQAB
     startTimestamp = system_clock::now();
     this->voiceServerManager->executeAutostart();
 
-    this->scheduler()->schedule(INSTANCE_TICK_NAME, bind(&InstanceHandler::tickInstance, this), milliseconds(100));
+    this->scheduler()->schedule(INSTANCE_TICK_NAME, bind(&InstanceHandler::tickInstance, this), milliseconds{500});
     return true;
 }
 
@@ -482,12 +481,12 @@ void InstanceHandler::tickInstance() {
         ALARM_TIMER(t, "InstanceHandler::tickInstance -> flush", milliseconds(5));
         //logger::flush();
     }
-    if(statisticsUpdateTimestamp + seconds(5) < now) {
+    {
+        ALARM_TIMER(t, "InstanceHandler::tickInstance -> statistics tick", milliseconds(5));
+        this->statistics->tick();
+    }
+    if(statisticsUpdateTimestamp + seconds(1) < now) {
         statisticsUpdateTimestamp = now;
-        {
-            ALARM_TIMER(t, "InstanceHandler::tickInstance -> statistics tick", milliseconds(5));
-            this->statistics->tick();
-        }
 
         {
             ALARM_TIMER(t, "InstanceHandler::tickInstance -> statistics tick [monthly]", milliseconds(2));

server/src/InstanceHandler.h

@@ -42,7 +42,7 @@ namespace ts {
                 std::shared_mutex& getChannelTreeLock() { return this->default_tree_lock; }
 
                 VirtualServerManager* getVoiceServerManager(){ return this->voiceServerManager; }
-                FileServer* getFileServer(){ return fileServer; }
+                LocalFileServer* getFileServer(){ return fileServer; }
                 QueryServer* getQueryServer(){ return queryServer; }
                 DatabaseHelper* databaseHelper(){ return this->dbHelper; }
                 BanManager* banManager(){ return this->banMgr; }
@@ -110,7 +110,7 @@ namespace ts {
                 std::chrono::system_clock::time_point memcleanTimestamp;
                 SqlDataManager* sql;
 
-                FileServer* fileServer = nullptr;
+                LocalFileServer* fileServer = nullptr;
                 QueryServer* queryServer = nullptr;
                 VirtualServerManager* voiceServerManager = nullptr;
                 DatabaseHelper* dbHelper = nullptr;

server/src/InstanceHandlerSetup.cpp

@@ -6,7 +6,7 @@
 #include "InstanceHandler.h"
 #include "src/client/InternalClient.h"
 #include "src/server/QueryServer.h"
-#include "src/server/file/FileServer.h"
+#include "src/server/file/LocalFileServer.h"
 
 using namespace std;
 using namespace std::chrono;
@@ -134,8 +134,8 @@ bool InstanceHandler::setupDefaultGroups() {
         }
 
         for(const auto& property : info->properties) {
-            const auto& prop = property::impl::info<property::InstanceProperties>(property);
-            if(*prop == property::SERVERINSTANCE_UNDEFINED) {
+            const auto& prop = property::find<property::InstanceProperties>(property);
+            if(prop.is_undefined()) {
                 logCritical(LOG_INSTANCE, "Invalid template property name: " + property);
             } else {
                 this->properties()[prop] = group->groupId();

server/src/ServerManagerSnapshotDeploy.cpp

@@ -201,7 +201,7 @@ std::shared_ptr<VirtualServer> VirtualServerManager::createServerFromSnapshot(sh
     auto snapshot_version = arguments[index].has("snapshot_version") ? arguments[index++]["snapshot_version"] : 0;
     debugMessage(0, "Got server snapshot with version {}", snapshot_version);
     while(true){
-        for(auto &key : arguments[index].keys()){
+        for(const auto &key : arguments[index].keys()){
             if(key == "end_virtualserver") continue;
             if(key == "begin_virtualserver") continue;
             if(snapshot_version == 0) {
@@ -559,8 +559,8 @@ std::shared_ptr<VirtualServer> VirtualServerManager::createServerFromSnapshot(sh
                             if(key == "bot_owner_id") continue;
                             if(key == "bot_id") continue;
 
-                            const auto& property = property::info<property::ClientProperties>(key);
-                            if(property->property_index == property::CLIENT_UNDEFINED) {
+                            const auto& property = property::find<property::ClientProperties>(key);
+                            if(property.is_undefined()) {
                                 debugMessage(log_server_id, PREFIX + "Failed to parse give music bot property {} for bot {} (old: {}). Value: {}", key, new_bot_id, bot_id, arguments[index][key].string());
                                 continue;
                             }
@@ -597,8 +597,8 @@ std::shared_ptr<VirtualServer> VirtualServerManager::createServerFromSnapshot(sh
                             if(key == "begin_playlist") continue;
                             if(key == "playlist_id") continue;
 
-                            const auto& property = property::info<property::ClientProperties>(key);
-                            if(property->property_index == property::CLIENT_UNDEFINED) {
+                            const auto& property = property::find<property::ClientProperties>(key);
+                            if(property.is_undefined()) {
                                 debugMessage(log_server_id, PREFIX + "Failed to parse given playlist property {} for playlist {} (old: {}). Value: {}", key, playlist_index, playlist_id, arguments[index][key].string());
                                 continue;
                             }
@@ -787,12 +787,12 @@ bool VirtualServerManager::createServerSnapshot(Command &cmd, shared_ptr<Virtual
                     case property::VIRTUALSERVER_UPLOAD_QUOTA:
                     case property::VIRTUALSERVER_MAX_DOWNLOAD_TOTAL_BANDWIDTH:
                     case property::VIRTUALSERVER_MAX_UPLOAD_TOTAL_BANDWIDTH:
-                        cmd[index][serverProperty.type().name] = (uint64_t) serverProperty.as_save<int64_t>();
+                        cmd[index][std::string{serverProperty.type().name}] = (uint64_t) serverProperty.as_save<int64_t>();
                     default:
                         break;
                 }
             }
-            cmd[index][serverProperty.type().name] = serverProperty.value();
+            cmd[index][std::string{serverProperty.type().name}] = serverProperty.value();
         }
         cmd[index++]["end_virtualserver"] = "";
     }
@@ -807,7 +807,7 @@ bool VirtualServerManager::createServerSnapshot(Command &cmd, shared_ptr<Virtual
                 else if(channelProperty.type() == property::CHANNEL_PID)
                     cmd[index]["channel_pid"] = channelProperty.as<string>();
                 else
-                    cmd[index][channelProperty.type().name] = channelProperty.as<string>();
+                    cmd[index][std::string{channelProperty.type().name}] = channelProperty.as<string>();
             }
             index++;
         }
@@ -899,7 +899,7 @@ bool VirtualServerManager::createServerSnapshot(Command &cmd, shared_ptr<Virtual
                     if((property->type->flags & (property::FLAG_SAVE_MUSIC | property::FLAG_SAVE)) == 0) continue;
                     if(property->value == property->type->default_value) continue;
 
-                    cmd[index][property->type->name] = property->value;
+                    cmd[index][std::string{property->type->name}] = property->value;
                 }
 
                 index++;
@@ -931,7 +931,7 @@ bool VirtualServerManager::createServerSnapshot(Command &cmd, shared_ptr<Virtual
                     if((property->type->flags & (property::FLAG_SAVE_MUSIC | property::FLAG_SAVE)) == 0) continue;
                     if(property->value == property->type->default_value) continue;
 
-                    cmd[index][property->type->name] = property->value;
+                    cmd[index][std::string{property->type->name}] = property->value;
                 }
 
                 index++;

server/src/ShutdownHelper.cpp

@@ -31,6 +31,7 @@ void ts::server::shutdownInstance(const std::string& message) {
         force_kill.detach();
 
         exit(2);
+        //kill(0, SIGKILL);
     });
     threads::name(hangup_controller, "stop controller");
     hangup_controller.detach();

server/src/TS3ServerHeartbeat.cpp

@@ -87,8 +87,7 @@ void VirtualServer::executeServerTick() {
             if(clientOnline + queryOnline == 0) //We don't need to tick, when server is empty!
                 return;
             properties()[property::VIRTUALSERVER_CHANNELS_ONLINE] = this->channelTree->channel_count();
-            properties()[property::VIRTUALSERVER_TOTAL_PING] = this->averagePing();
-
+            properties()[property::VIRTUALSERVER_TOTAL_PING] = this->generate_network_report().average_ping;
             END_TIMINGS(timing_update_states);
         }
         

server/src/VirtualServer.cpp

@@ -18,7 +18,7 @@
 #include "./client/query/QueryClient.h"
 #include "music/MusicBotManager.h"
 #include "server/VoiceServer.h"
-#include "server/file/FileServer.h"
+#include "src/server/file/LocalFileServer.h"
 #include "server/QueryServer.h"
 #include "InstanceHandler.h"
 #include "Configuration.h"
@@ -57,7 +57,7 @@ bool VirtualServer::initialize(bool test_properties) {
             this->_voice_encryption_mode = prop.as<int>();
             return;
         }
-        std::string sql;
+        std::string sql{};
         if(prop.type() == property::VIRTUALSERVER_HOST)
             sql = "UPDATE `servers` SET `host` = :value WHERE `serverId` = :sid";
         else if(prop.type() == property::VIRTUALSERVER_PORT)
@@ -129,6 +129,7 @@ bool VirtualServer::initialize(bool test_properties) {
         return false;
     }
 
+    channelTree->deleteSemiPermanentChannels();
     if(channelTree->channel_count() == 0){
         logMessage(this->serverId, "Creating new channel tree (Copy from server 0)");
         LOG_SQL_CMD(sql::command(this->getSql(), "INSERT INTO `channels` (`serverId`, `channelId`, `type`, `parentId`) SELECT :serverId AS `serverId`, `channelId`, `type`, `parentId` FROM `channels` WHERE `serverId` = 0", variable{":serverId", this->serverId}).execute());
@@ -141,7 +142,7 @@ bool VirtualServer::initialize(bool test_properties) {
         channelTree->loadChannelsFromDatabase();
         if(channelTree->channel_count() == 0){
             logCritical(this->serverId, "Failed to setup channel tree!");
-            return 0;
+            return false;
         }
         if(!channelTree->getDefaultChannel()) {
             logError(this->serverId, "Missing default channel! Using first one!");
@@ -180,7 +181,7 @@ bool VirtualServer::initialize(bool test_properties) {
 
     letters = new letter::LetterManager(this);
 
-    serverStatistics = make_shared<stats::ConnectionStatistics>(serverInstance->getStatistics(), true);
+    serverStatistics = make_shared<stats::ConnectionStatistics>(serverInstance->getStatistics());
 
     this->serverRoot = std::make_shared<InternalClient>(this->sql, self.lock(), this->properties()[property::VIRTUALSERVER_NAME].as<string>(), false);
     static_pointer_cast<InternalClient>(this->serverRoot)->setSharedLock(this->serverRoot);
@@ -216,12 +217,13 @@ bool VirtualServer::initialize(bool test_properties) {
         property::VIRTUALSERVER_MAX_UPLOAD_TOTAL_BANDWIDTH,
         property::VIRTUALSERVER_MAX_DOWNLOAD_TOTAL_BANDWIDTH,
     }) {
-        auto info = property::impl::info(type);
+        const auto& info = property::describe(type);
         auto prop = this->properties()[type];
         if(prop.default_value() == prop.value()) continue;
-        if(!info->validate_input(this->properties()[type].value())) {
-            this->properties()[type] = info->default_value;
-            logMessage(this->getServerId(), "Server property " + info->name + " contains an invalid value! Resetting it.");
+
+        if(!info.validate_input(this->properties()[type].value())) {
+            this->properties()[type] = info.default_value;
+            logMessage(this->getServerId(), "Server property " + std::string{info.name} + " contains an invalid value! Resetting it.");
         }
     }
 
@@ -711,8 +713,8 @@ bool VirtualServer::notifyServerEdited(std::shared_ptr<ConnectedClient> invoker,
     cmd["invokeruid"] = invoker->getUid();
     cmd["reasonid"] = ViewReasonId::VREASON_EDITED;
     for(const auto& key : keys) {
-        auto info = property::impl::info<property::VirtualServerProperties>(key);
-        if(*info == property::VIRTUALSERVER_UNDEFINED) {
+        const auto& info = property::find<property::VirtualServerProperties>(key);
+        if(info == property::VIRTUALSERVER_UNDEFINED) {
             logError(this->getServerId(), "Tried to broadcast a server update with an unknown info: " + key);
             continue;
         }
@@ -724,10 +726,10 @@ bool VirtualServer::notifyServerEdited(std::shared_ptr<ConnectedClient> invoker,
     return true;
 }
 
-bool VirtualServer::notifyClientPropertyUpdates(std::shared_ptr<ConnectedClient> client, const deque<shared_ptr<property::PropertyDescription>>& keys, bool selfNotify) {
-    if(keys.empty()) return false;
+bool VirtualServer::notifyClientPropertyUpdates(std::shared_ptr<ConnectedClient> client, const deque<const property::PropertyDescription*>& keys, bool selfNotify) {
+    if(keys.empty() || !client) return false;
     this->forEachClient([&](const shared_ptr<ConnectedClient>& cl) {
-        shared_lock client_channel_lock(client->channel_lock);
+        shared_lock client_channel_lock(cl->channel_lock);
         if(cl->isClientVisible(client, false) || (cl == client && selfNotify))
             cl->notifyClientUpdated(client, keys, false);
     });
@@ -1017,35 +1019,33 @@ bool VirtualServer::verifyServerPassword(std::string password, bool hashed) {
     return password == this->properties()[property::VIRTUALSERVER_PASSWORD].as<std::string>();
 }
 
-float VirtualServer::averagePacketLoss() {
-    //TODO Average packet loss
-    return 0.f;
-}
+VirtualServer::NetworkReport VirtualServer::generate_network_report() {
+    double total_ping{0}, total_loss{0};
+    size_t pings_counted{0}, loss_counted{0};
 
-float VirtualServer::averagePing() {
-    float count = 0;
-    float sum = 0;
-
-    this->forEachClient([&count, &sum](shared_ptr<ConnectedClient> client) {
-        auto type = client->getType();
-        if(type == ClientType::CLIENT_TEAMSPEAK || type == ClientType::CLIENT_TEASPEAK) {
-            count++;
-            sum += duration_cast<milliseconds>(dynamic_pointer_cast<VoiceClient>(client)->calculatePing()).count();
+    this->forEachClient([&](const std::shared_ptr<ConnectedClient>& client) {
+        if(auto vc = dynamic_pointer_cast<VoiceClient>(client); vc) {
+            total_ping += vc->current_ping().count();
+            total_loss += vc->current_packet_loss();
+            pings_counted++;
+            loss_counted++;
         }
 #ifdef COMPILE_WEB_CLIENT
-        else if(type == ClientType::CLIENT_WEB) {
-            count++;
-            sum += duration_cast<milliseconds>(dynamic_pointer_cast<WebClient>(client)->client_ping()).count();
+        else if(client->getType() == ClientType::CLIENT_WEB) {
+            pings_counted++;
+            total_ping += duration_cast<milliseconds>(dynamic_pointer_cast<WebClient>(client)->client_ping()).count();
         }
 #endif
     });
 
-    if(count == 0) return 0;
-    return sum / count;
+    VirtualServer::NetworkReport result{};
+    if(loss_counted) result.average_loss = total_loss / loss_counted;
+    if(pings_counted) result.average_ping = total_ping / pings_counted;
+    return result;
 }
 
 bool VirtualServer::resetPermissions(std::string& token) {
-    LOG_SQL_CMD(sql::command(this->sql, "DELETE FROM `permissions` WHERE `serverId` = :serverId", variable{":serverId", this->serverId}).execute());
+    LOG_SQL_CMD(sql::command(this->sql, "DELETE FROM `permissions` WHERE `serverId` = :serverId AND `type` != :channel_type", variable{":serverId", this->serverId}, variable{":channel_type", permission::SQL_PERM_CHANNEL}).execute());
     LOG_SQL_CMD(sql::command(this->sql, "DELETE FROM `assignedGroups` WHERE `serverId` = :serverId", variable{":serverId", this->serverId}).execute());
     LOG_SQL_CMD(sql::command(this->sql, "DELETE FROM `groups` WHERE `serverId` = :serverId", variable{":serverId", this->serverId}).execute());
 
@@ -1217,4 +1217,41 @@ void VirtualServer::send_text_message(const std::shared_ptr<BasicChannel> &chann
         auto conversation = conversations->get_or_create(channel->channelId());
         conversation->register_message(sender->getClientDatabaseId(), sender->getUid(), sender->getDisplayName(), now, message);
     }
+}
+
+void VirtualServer::update_channel_from_permissions(const std::shared_ptr<BasicChannel> &channel, const std::shared_ptr<ConnectedClient>& issuer) {
+    bool require_view_update;
+    auto property_updates = channel->update_properties_from_permissions(require_view_update);
+
+    if(!property_updates.empty()) {
+        this->forEachClient([&](const std::shared_ptr<ConnectedClient>& cl) {
+            shared_lock client_channel_lock(cl->channel_lock);
+            cl->notifyChannelEdited(channel, property_updates, issuer, false);
+        });
+    }
+
+    if(require_view_update) {
+        auto l_source = this->channelTree->findLinkedChannel(channel->channelId());
+        this->forEachClient([&](const shared_ptr<ConnectedClient>& cl) {
+            /* server tree read lock still active */
+            auto l_target = !cl->currentChannel ? nullptr : cl->server->channelTree->findLinkedChannel(cl->currentChannel->channelId());
+            sassert(l_source);
+            if(cl->currentChannel) sassert(l_target);
+
+            {
+                unique_lock client_channel_lock(cl->channel_lock);
+
+                deque<ChannelId> deleted;
+                for(const auto& [flag_visible, channel] : cl->channels->update_channel(l_source, l_target)) {
+                    if(flag_visible) {
+                        cl->notifyChannelShow(channel->channel(), channel->previous_channel);
+                    } else {
+                        deleted.push_back(channel->channelId());
+                    }
+                }
+                if(!deleted.empty())
+                    cl->notifyChannelHide(deleted, false);
+            }
+        });
+    }
 }

server/src/VirtualServer.h

@@ -58,7 +58,7 @@ namespace ts {
         class InstanceHandler;
         class VoiceServer;
         class QueryServer;
-        class FileServer;
+        class LocalFileServer;
         class SpeakingClient;
 
         class WebControlServer;
@@ -136,6 +136,11 @@ namespace ts {
                 friend class InstanceHandler;
                 friend class VirtualServerManager;
             public:
+                struct NetworkReport {
+                    float average_ping{0};
+                    float average_loss{0};
+                };
+                
                 VirtualServer(ServerId serverId, sql::SqlManager*);
                 ~VirtualServer();
 
@@ -182,11 +187,11 @@ namespace ts {
                 inline GroupManager* getGroupManager() { return this->groups; }
 
                 bool notifyServerEdited(std::shared_ptr<ConnectedClient>, std::deque<std::string> keys);
-                bool notifyClientPropertyUpdates(std::shared_ptr<ConnectedClient>, const std::deque<std::shared_ptr<property::PropertyDescription>>& keys, bool selfNotify = true); /* execute only with at least channel tree read lock! */
+                bool notifyClientPropertyUpdates(std::shared_ptr<ConnectedClient>, const std::deque<const property::PropertyDescription*>& keys, bool selfNotify = true); /* execute only with at least channel tree read lock! */
                 inline bool notifyClientPropertyUpdates(const std::shared_ptr<ConnectedClient>& client, const std::deque<property::ClientProperties>& keys, bool selfNotify = true) {
                     if(keys.empty()) return false;
-                    std::deque<std::shared_ptr<property::PropertyDescription>> _keys;
-                    for(const auto& key : keys) _keys.push_back(property::impl::info<property::ClientProperties>(key));
+                    std::deque<const property::PropertyDescription*> _keys{};
+                    for(const auto& key : keys) _keys.push_back(&property::describe(key));
                     return this->notifyClientPropertyUpdates(client, _keys, selfNotify);
                 };
 
@@ -230,8 +235,7 @@ namespace ts {
 
                 void testBanStateChange(const std::shared_ptr<ConnectedClient>& invoker);
 
-                float averagePing();
-                float averagePacketLoss();
+                [[nodiscard]] NetworkReport generate_network_report();
 
                 bool resetPermissions(std::string&);
                 void ensureValidDefaultGroups();
@@ -274,6 +278,9 @@ namespace ts {
 
                 inline int voice_encryption_mode() { return this->_voice_encryption_mode; }
                 inline std::shared_ptr<conversation::ConversationManager> conversation_manager() { return this->_conversation_manager; }
+
+
+                void update_channel_from_permissions(const std::shared_ptr<BasicChannel>& /* channel */, const std::shared_ptr<ConnectedClient>& /* issuer */);
             protected:
                 bool registerClient(std::shared_ptr<ConnectedClient>);
                 bool unregisterClient(std::shared_ptr<ConnectedClient>, std::string, std::unique_lock<std::shared_mutex>& channel_tree_lock);

server/src/VirtualServerManager.cpp

@@ -4,7 +4,7 @@
 #include "src/server/VoiceServer.h"
 #include "src/client/query/QueryClient.h"
 #include "InstanceHandler.h"
-#include "src/server/file/FileServer.h"
+#include "src/server/file/LocalFileServer.h"
 #include "src/client/ConnectedClient.h"
 #include <ThreadPool/ThreadHelper.h>
 
@@ -13,7 +13,7 @@ using namespace std::chrono;
 using namespace ts::server;
 
 VirtualServerManager::VirtualServerManager(InstanceHandler* handle) : handle(handle) {
-    this->puzzles = new protocol::PuzzleManager();
+    this->puzzles = new udp::PuzzleManager{};
     this->handshakeTickers = new threads::Scheduler(1, "handshake ticker");
     this->execute_loop = new event::EventExecutor("executor #");
     //this->join_loop = new event::EventExecutor("joiner #");
@@ -67,7 +67,8 @@ bool VirtualServerManager::initialize(bool autostart) {
     this->state = State::STARTING;
     logMessage(LOG_INSTANCE, "Generating server puzzles...");
     auto start = system_clock::now();
-    this->puzzles->precomputePuzzles(config::voice::DefaultPuzzlePrecomputeSize);
+    if(!this->puzzles->precompute_puzzles(config::voice::DefaultPuzzlePrecomputeSize))
+        logCritical(LOG_INSTANCE, "Failed to precompute RSA puzzles");
     logMessage(LOG_INSTANCE, "Puzzles generated! Time required: " + to_string(duration_cast<milliseconds>(system_clock::now() - start).count()) + "ms");
 
     size_t serverCount = 0;
@@ -200,9 +201,11 @@ shared_ptr<VirtualServer> VirtualServerManager::findServerByPort(uint16_t port)
     return nullptr;
 }
 
-uint16_t VirtualServerManager::next_available_port() {
+uint16_t VirtualServerManager::next_available_port(const std::string& host_string) {
     auto instances = this->serverInstances();
-    deque<uint16_t> unallowed_ports;
+    std::vector<uint16_t> unallowed_ports{};
+    unallowed_ports.reserve(instances.size());
+
     for(const auto& instance : instances) {
         unallowed_ports.push_back(instance->properties()[property::VIRTUALSERVER_PORT].as<uint16_t>());
 
@@ -213,18 +216,39 @@ uint16_t VirtualServerManager::next_available_port() {
             }
         }
     }
+    auto bindings = net::resolve_bindings(host_string, 0);
 
     uint16_t port = config::voice::default_voice_port;
     while(true) {
-        if(port < 1024) goto c;
+        if(port < 1024) goto next_port;
 
         for(auto& p : unallowed_ports) {
             if(p == port)
-                goto c;
+                goto next_port;
+        }
+
+        for(auto& binding : bindings) {
+            if(!std::get<2>(binding).empty()) continue; /* error on that */
+            auto& baddress = std::get<1>(binding);
+            auto& raw_port = baddress.ss_family == AF_INET ? ((sockaddr_in*) &baddress)->sin_port : ((sockaddr_in6*) &baddress)->sin6_port;
+            raw_port = htons(port);
+
+            switch (net::address_available(baddress, net::binding_type::TCP)) {
+                case net::binding_result::ADDRESS_USED:
+                    goto next_port;
+                default:
+                    break; /* if we've an internal error we ignore it */
+            }
+            switch (net::address_available(baddress, net::binding_type::UDP)) {
+                case net::binding_result::ADDRESS_USED:
+                    goto next_port;
+                default:
+                    break; /* if we've an internal error we ignore it */
+            }
         }
         break;
 
-        c:
+        next_port:
         port++;
     }
     return port;
@@ -316,8 +340,9 @@ shared_ptr<VirtualServer> VirtualServerManager::create_server(std::string hosts,
     if(!sid_success)
         return nullptr;
 
+    this->delete_server_in_db(serverId); /* just to ensure */
     sql::command(this->handle->getSql(), "INSERT INTO `servers` (`serverId`, `host`, `port`) VALUES (:sid, :host, :port)", variable{":sid", serverId}, variable{":host", hosts}, variable{":port", port}).executeLater().waitAndGetLater(LOG_SQL_CMD, {1, "future failed"});
-    //`serverId` INTEGER DEFAULT -1, `type` INTEGER, `id` INTEGER, `key` VARCHAR(" UNKNOWN_KEY_LENGTH "), `value` TEXT
+
     auto prop_copy = sql::command(this->handle->getSql(), "INSERT INTO `properties` (`serverId`, `type`, `id`, `key`, `value`) SELECT :target_sid AS `serverId`, `type`, `id`, `key`, `value` FROM `properties` WHERE `type` = :type AND `id` = 0 AND `serverId` = 0;",
                  variable{":target_sid", serverId},
                  variable{":type", property::PROP_TYPE_SERVER}).execute();
@@ -393,21 +418,8 @@ bool VirtualServerManager::deleteServer(shared_ptr<VirtualServer> server) {
     }
 
     this->handle->properties()[property::SERVERINSTANCE_SPOKEN_TIME_DELETED] += server->properties()[property::VIRTUALSERVER_SPOKEN_TIME].as<uint64_t>();
-    sql::command(this->handle->getSql(), "DELETE FROM `tokens` WHERE `serverId` = :sid", variable{":sid", server->getServerId()}).executeLater().waitAndGetLater(LOG_SQL_CMD, {1, "future failed"});
-    sql::command(this->handle->getSql(), "DELETE FROM `properties` WHERE `serverId` = :sid", variable{":sid", server->getServerId()}).executeLater().waitAndGetLater(LOG_SQL_CMD, {1, "future failed"});
-    sql::command(this->handle->getSql(), "DELETE FROM `permissions` WHERE `serverId` = :sid", variable{":sid", server->getServerId()}).executeLater().waitAndGetLater(LOG_SQL_CMD, {1, "future failed"});
-    sql::command(this->handle->getSql(), "DELETE FROM `groups` WHERE `serverId` = :sid", variable{":sid", server->getServerId()}).executeLater().waitAndGetLater(LOG_SQL_CMD, {1, "future failed"});
-    sql::command(this->handle->getSql(), "DELETE FROM `clients` WHERE `serverId` = :sid", variable{":sid", server->getServerId()}).executeLater().waitAndGetLater(LOG_SQL_CMD, {1, "future failed"});
-    sql::command(this->handle->getSql(), "DELETE FROM `channels` WHERE `serverId` = :sid", variable{":sid", server->getServerId()}).executeLater().waitAndGetLater(LOG_SQL_CMD, {1, "future failed"});
-    sql::command(this->handle->getSql(), "DELETE FROM `bannedClients` WHERE `serverId` = :sid", variable{":sid", server->getServerId()}).executeLater().waitAndGetLater(LOG_SQL_CMD, {1, "future failed"});
-    sql::command(this->handle->getSql(), "DELETE FROM `assignedGroups` WHERE `serverId` = :sid", variable{":sid", server->getServerId()}).executeLater().waitAndGetLater(LOG_SQL_CMD, {1, "future failed"});
-    sql::command(this->handle->getSql(), "DELETE FROM `servers` WHERE `serverId` = :sid", variable{":sid", server->getServerId()}).executeLater().waitAndGetLater(LOG_SQL_CMD, {1, "future failed"});
-    sql::command(this->handle->getSql(), "DELETE FROM `musicbots` WHERE `serverId` = :sid", variable{":sid", server->getServerId()}).executeLater().waitAndGetLater(LOG_SQL_CMD, {1, "future failed"});
-
-    sql::command(this->handle->getSql(), "DELETE FROM `bannedClients` WHERE `serverId` = :sid", variable{":sid", server->getServerId()}).executeLater().waitAndGetLater(LOG_SQL_CMD, {1, "future failed"});
-    sql::command(this->handle->getSql(), "DELETE FROM `ban_trigger` WHERE `server_id` = :sid", variable{":sid", server->getServerId()}).executeLater().waitAndGetLater(LOG_SQL_CMD, {1, "future failed"});
+    this->delete_server_in_db(server->serverId);
     this->handle->getFileServer()->deleteServer(server);
-
     return true;
 }
 
@@ -446,4 +458,33 @@ void VirtualServerManager::tickHandshakeClients() {
         if(vserver)
             vserver->tickHandshakingClients();
     }
+}
+
+void VirtualServerManager::delete_server_in_db(ts::ServerId server_id) {
+#define execute_delete(statement) \
+result = sql::command(this->handle->getSql(), statement, variable{":sid", server_id}).execute(); \
+if(!result) { \
+    logWarning(LOG_INSTANCE, "Failed to execute SQL command {}: {}", statement, result.fmtStr()); \
+    result = sql::result{}; \
+}
+
+    sql::result result{};
+
+    execute_delete("DELETE FROM `tokens` WHERE `serverId` = :sid");
+    execute_delete("DELETE FROM `properties` WHERE `serverId` = :sid");
+    execute_delete("DELETE FROM `permissions` WHERE `serverId` = :sid");
+    execute_delete("DELETE FROM `clients` WHERE `serverId` = :sid");
+    execute_delete("DELETE FROM `channels` WHERE `serverId` = :sid");
+    execute_delete("DELETE FROM `bannedClients` WHERE `serverId` = :sid");
+    execute_delete("DELETE FROM `ban_trigger` WHERE `server_id` = :sid");
+    execute_delete("DELETE FROM `groups` WHERE `serverId` = :sid");
+    execute_delete("DELETE FROM `assignedGroups` WHERE `serverId` = :sid");
+    execute_delete("DELETE FROM `servers` WHERE `serverId` = :sid");
+
+    execute_delete("DELETE FROM `musicbots` WHERE `serverId` = :sid");
+    execute_delete("DELETE FROM `conversations` WHERE `server_id` = :sid");
+    execute_delete("DELETE FROM `conversation_blocks` WHERE `server_id` = :sid");
+
+    execute_delete("DELETE FROM `playlists` WHERE `serverId` = :sid");
+    execute_delete("DELETE FROM `playlist_songs` WHERE `serverId` = :sid");
 }

server/src/VirtualServerManager.h

@@ -5,95 +5,104 @@
 #include "client/voice/PrecomputedPuzzles.h"
 #include "server/VoiceIOManager.h"
 #include "VirtualServer.h"
+#include <query/command3.h>
+#include "snapshots/snapshot.h"
 
-namespace ts {
-    namespace server {
-        class InstanceHandler;
+namespace ts::server {
+    class InstanceHandler;
 
-        struct ServerReport {
-            size_t avariable;
-            size_t online;
+    struct ServerReport {
+        size_t avariable;
+        size_t online;
 
-            size_t slots;
-            size_t onlineClients;
-            size_t onlineChannels;
-        };
-        class VirtualServerManager {
-            public:
-                enum State {
-                    STOPPED,
-                    STARTING,
-                    STARTED,
-                    STOPPING
-                };
+        size_t slots;
+        size_t onlineClients;
+        size_t onlineChannels;
+    };
+    class VirtualServerManager {
+        public:
+            enum State {
+                STOPPED,
+                STARTING,
+                STARTED,
+                STOPPING
+            };
 
-                explicit VirtualServerManager(InstanceHandler*);
-                ~VirtualServerManager();
+            explicit VirtualServerManager(InstanceHandler*);
+            ~VirtualServerManager();
 
-                bool initialize(bool execute_autostart = true);
+            bool initialize(bool execute_autostart = true);
 
-                std::shared_ptr<VirtualServer> create_server(std::string hosts, uint16_t port);
-                bool deleteServer(std::shared_ptr<VirtualServer>);
+            std::shared_ptr<VirtualServer> create_server(std::string hosts, uint16_t port);
+            bool deleteServer(std::shared_ptr<VirtualServer>);
 
-                std::shared_ptr<VirtualServer> findServerById(ServerId);
-                std::shared_ptr<VirtualServer> findServerByPort(uint16_t);
-                uint16_t next_available_port();
-                ServerId next_available_server_id(bool& /* success */);
-                
-                std::deque<std::shared_ptr<VirtualServer>> serverInstances(){
-                    threads::MutexLock l(this->instanceLock);
-                    return instances;
-                }
+            std::shared_ptr<VirtualServer> findServerById(ServerId);
+            std::shared_ptr<VirtualServer> findServerByPort(uint16_t);
+            uint16_t next_available_port(const std::string& /* host string */);
+            ServerId next_available_server_id(bool& /* success */);
 
-                ServerReport report();
-                OnlineClientReport clientReport();
-                size_t runningServers();
-                size_t usedSlots();
+            std::deque<std::shared_ptr<VirtualServer>> serverInstances(){
+                threads::MutexLock l(this->instanceLock);
+                return instances;
+            }
 
-                void executeAutostart();
-                void shutdownAll(const std::string&);
+            ServerReport report();
+            OnlineClientReport clientReport();
+            size_t runningServers();
+            size_t usedSlots();
 
-                //Dotn use shared_ptr references to keep sure that they be hold in memory
-                bool createServerSnapshot(Command &cmd, std::shared_ptr<VirtualServer> server, int version, std::string &error);
-                std::shared_ptr<VirtualServer> createServerFromSnapshot(std::shared_ptr<VirtualServer> old, std::string, uint16_t, const ts::Command &, std::string &);
+            void executeAutostart();
+            void shutdownAll(const std::string&);
 
-                protocol::PuzzleManager* rsaPuzzles() { return this->puzzles; }
+            //Dotn use shared_ptr references to keep sure that they be hold in memory
+            bool createServerSnapshot(Command &cmd, std::shared_ptr<VirtualServer> server, int version, std::string &error);
+            std::shared_ptr<VirtualServer> createServerFromSnapshot(std::shared_ptr<VirtualServer> old, std::string, uint16_t, const ts::Command &, std::string &);
+            bool deploy_snapshot(std::string& /* error */, ServerId /* target server id */, const command_parser& /* source */);
 
-                event::EventExecutor* get_join_loop() { return this->join_loop; }
-                event::EventExecutor* get_executor_loop() { return this->execute_loop; }
+            udp::PuzzleManager* rsaPuzzles() { return this->puzzles; }
 
-                inline void adjust_executor_threads() {
-                    std::unique_lock instance_lock(this->instanceLock);
-                    auto instance_count = this->instances.size();
-                    instance_lock.unlock();
+            event::EventExecutor* get_join_loop() { return this->join_loop; }
+            event::EventExecutor* get_executor_loop() { return this->execute_loop; }
 
-                    auto threads = std::min(config::threads::voice::execute_per_server * instance_count, config::threads::voice::execute_limit);
-                    this->execute_loop->threads(threads);
-                }
-                io::VoiceIOManager* ioManager(){ return this->_ioManager; }
+            inline void adjust_executor_threads() {
+                std::unique_lock instance_lock(this->instanceLock);
+                auto instance_count = this->instances.size();
+                instance_lock.unlock();
 
-                threads::Mutex server_create_lock;
+                auto threads = std::min(config::threads::voice::execute_per_server * instance_count, config::threads::voice::execute_limit);
+                this->execute_loop->threads(threads);
+            }
+            io::VoiceIOManager* ioManager(){ return this->_ioManager; }
 
-                State getState() { return this->state; }
-            private:
-                State state = State::STOPPED;
-                InstanceHandler* handle;
-                threads::Mutex instanceLock;
-                std::deque<std::shared_ptr<VirtualServer>> instances;
-                protocol::PuzzleManager* puzzles = nullptr;
+            threads::Mutex server_create_lock;
 
-                event::EventExecutor* execute_loop = nullptr;
-                event::EventExecutor* join_loop = nullptr;
-                threads::Scheduler* handshakeTickers = nullptr;
-                io::VoiceIOManager* _ioManager = nullptr;
+            State getState() { return this->state; }
+        private:
+            State state = State::STOPPED;
+            InstanceHandler* handle;
+            threads::Mutex instanceLock;
+            std::deque<std::shared_ptr<VirtualServer>> instances;
+            udp::PuzzleManager* puzzles{nullptr};
 
-                struct {
-                    std::thread executor{};
-                    std::condition_variable condition;
-                    std::mutex lock;
-                } acknowledge;
+            event::EventExecutor* execute_loop = nullptr;
+            event::EventExecutor* join_loop = nullptr;
+            threads::Scheduler* handshakeTickers = nullptr;
+            io::VoiceIOManager* _ioManager = nullptr;
 
-                void tickHandshakeClients();
-        };
-    }
+            struct {
+                std::thread executor{};
+                std::condition_variable condition;
+                std::mutex lock;
+            } acknowledge;
+
+            void tickHandshakeClients();
+
+            void delete_server_in_db(ServerId /* server id */);
+
+            /* methods used to preprocess a snapshot */
+            bool deploy_ts3_snapshot(std::string& /* error */, ServerId /* target server id */, const command_parser& /* source */);
+            bool deploy_teaspeak_snapshot(std::string& /* error */, ServerId /* target server id */, const command_parser& /* source */);
+            /* actual deploy method */
+            bool deploy_raw_snapshot(std::string& /* error */, ServerId /* target server id */, const command_parser& /* source */, const std::string& /* hash */, size_t /* offset */, snapshots::type /* type */, snapshots::version_t /* version */);
+    };
 }

server/src/channel/ServerChannel.cpp

@@ -5,7 +5,7 @@
 #include "misc/rnd.h"
 #include "src/VirtualServer.h"
 #include "src/client/ConnectedClient.h"
-#include "src/server/file/FileServer.h"
+#include "src/server/file/LocalFileServer.h"
 #include "src/InstanceHandler.h"
 #include "../manager/ConversationManager.h"
 
@@ -102,7 +102,7 @@ std::shared_ptr<BasicChannel> ServerChannelTree::createChannel(ChannelId parentI
     channel->properties()[property::CHANNEL_LAST_LEFT] = chrono::duration_cast<chrono::milliseconds>(chrono::system_clock::now().time_since_epoch()).count();
 
 
-    auto result = sql::command(this->sql, "INSERT INTO `channels` (`serverId`, `channelId`, `type`, `parentId`) VALUES(:sid, :chid, :type, :parent);",  variable{":sid", this->getServerId()}, variable{":chid", channel->channelId()}, variable{":type", channel->channelType()}, variable{":parent", channel->parent() ? channel->parent()->channelId() : 0}).execute();
+    auto result = sql::command(this->sql, "INSERT INTO `channels` (`serverId`, `channelId`, `parentId`) VALUES(:sid, :chid, :parent);",  variable{":sid", this->getServerId()}, variable{":chid", channel->channelId()}, variable{":parent", channel->parent() ? channel->parent()->channelId() : 0}).execute();
     auto pf = LOG_SQL_CMD;
     pf(result);
 
@@ -493,7 +493,7 @@ bool ServerChannelTree::validateChannelIcons() {
 }
 
 void ServerChannelTree::loadChannelsFromDatabase() {
-    auto res = sql::command(this->sql, "SELECT * FROM `channels` WHERE `serverId` = :sid", variable{":sid", this->getServerId()}).query(&ServerChannelTree::loadChannelFromData, this);
+    auto res = sql::command(this->sql, "SELECT  `channelId`, `parentId` FROM `channels` WHERE `serverId` = :sid", variable{":sid", this->getServerId()}).query(&ServerChannelTree::loadChannelFromData, this);
     (LOG_SQL_CMD)(res);
     if(!res){
         logError(this->getServerId(), "Could not load channel tree from database");
@@ -512,7 +512,6 @@ void ServerChannelTree::loadChannelsFromDatabase() {
 int ServerChannelTree::loadChannelFromData(int argc, char **data, char **column) {
     ChannelId channelId = 0;
     ChannelId parentId = 0;
-    auto type = static_cast<ChannelType::ChannelType>(0xFF);
 
 
     int index = 0;
@@ -520,8 +519,6 @@ int ServerChannelTree::loadChannelFromData(int argc, char **data, char **column)
         for(index = 0; index < argc; index++){
             if(strcmp(column[index], "channelId") == 0) channelId = static_cast<ChannelId>(stoll(data[index]));
             else if(strcmp(column[index], "parentId") == 0) parentId = static_cast<ChannelId>(stoll(data[index]));
-            else if(strcmp(column[index], "type") == 0) type = static_cast<ChannelType::ChannelType>(stoll(data[index]));
-            else if(strcmp(column[index], "serverId") == 0) {}
             else logError(this->getServerId(), "ServerChannelTree::loadChannelFromData called with invalid column from sql \"{}\"", column[index]);
         }
     } catch (std::exception& ex) {

server/src/client/ConnectedClient.cpp

@@ -11,7 +11,7 @@
 #include "src/VirtualServer.h"
 #include "voice/VoiceClient.h"
 #include "../server/VoiceServer.h"
-#include "../server/file/FileServer.h"
+#include "src/server/file/LocalFileServer.h"
 #include "../InstanceHandler.h"
 #include "ConnectedClient.h"
 
@@ -29,9 +29,7 @@ ConnectedClient::ConnectedClient(sql::SqlManager* db, const std::shared_ptr<Virt
     memtrack::allocated<ConnectedClient>(this);
     memset(&this->remote_address, 0, sizeof(this->remote_address));
 
-    connectionStatistics = make_shared<stats::ConnectionStatistics>(server ? server->getServerStatistics() : nullptr, false);
-    this->connectionStatistics->measure_bandwidths(false); /* done by the client and we trust this */
-
+    connectionStatistics = make_shared<stats::ConnectionStatistics>(server ? server->getServerStatistics() : nullptr);
     channels = make_shared<ClientChannelView>(this);
 }
 
@@ -184,14 +182,17 @@ void ConnectedClient::updateChannelClientProperties(bool lock_channel_tree, bool
             client_channel_lock.lock();
         }
 
-        deque<ChannelId> deleted;
-        for(const auto& update_entry : this->channels->update_channel_path(server_ref->channelTree->tree_head(), server_ref->channelTree->find_linked_entry(this->currentChannel->channelId()))) {
-            if(update_entry.first)
-                this->notifyChannelShow(update_entry.second->channel(), update_entry.second->previous_channel);
-            else deleted.push_back(update_entry.second->channelId());
+        /* might have been changed since we locked the tree */
+        if(this->currentChannel) {
+            deque<ChannelId> deleted;
+            for(const auto& update_entry : this->channels->update_channel_path(server_ref->channelTree->tree_head(), server_ref->channelTree->find_linked_entry(this->currentChannel->channelId()))) {
+                if(update_entry.first)
+                    this->notifyChannelShow(update_entry.second->channel(), update_entry.second->previous_channel);
+                else deleted.push_back(update_entry.second->channelId());
+            }
+            if(!deleted.empty())
+                this->notifyChannelHide(deleted, false); /* we've locked the tree before */
         }
-        if(!deleted.empty())
-            this->notifyChannelHide(deleted, false); /* we've locked the tree before */
     }
 }
 
@@ -381,7 +382,7 @@ bool ConnectedClient::notifyClientLeftView(
         std::shared_ptr<ConnectedClient> invoker,
         bool lock_channel_tree) {
     assert(!lock_channel_tree); /* not supported yet! */
-    assert(client && client->getClientId() != 0);
+    assert(client == this || (client && client->getClientId() != 0));
     assert(client->currentChannel || &*client == this);
 
     if(client != this) {
@@ -564,31 +565,75 @@ bool ConnectedClient::notifyClientNeededPermissions() {
         cmd[index++]["permvalue"] = value.second.has_value ? value.second.value : 0;
     }
 
+    if(index == 0) {
+        cmd[index]["permid"] = permission::i_client_talk_power;
+        cmd[index++]["permvalue"] = 0;
+    }
+
     this->sendCommand(cmd);
     return true;
 }
 
+inline void write_command_result_error(ts::command_builder_bulk bulk, const command_result& result) {
+    bulk.put_unchecked("id", (uint32_t) result.error_code());
+    bulk.put_unchecked("msg", findError(result.error_code()).message);
+    if(result.is_permission_error())
+        bulk.put_unchecked("failed_permid", (uint32_t) result.permission_id());
+}
+
+inline void write_command_result_detailed(ts::command_builder_bulk bulk, const command_result& result) {
+    auto details = result.details();
+    bulk.put_unchecked("id", (uint32_t) details->error_id);
+    bulk.put_unchecked("msg", findError(details->error_id).message);
+
+    for(const auto& extra : details->extra_properties)
+        bulk.put(extra.first, extra.second);
+}
+
 bool ConnectedClient::notifyError(const command_result& result, const std::string& retCode) {
-    Command cmd("error");
+    ts::command_builder command{"error"};
 
-    if(result.is_detailed()) {
-        auto detailed = result.details();
-        cmd["id"] = (int) detailed->error_id;
-        cmd["msg"] = findError(detailed->error_id).message;
+    switch(result.type()) {
+        case command_result_type::error:
+            write_command_result_error(command.bulk(0), result);
+            break;
+        case command_result_type::detailed:
+            write_command_result_detailed(command.bulk(0), result);
+            break;
 
-        for(const auto& extra : detailed->extra_properties)
-            cmd[extra.first] = extra.second;
-    } else {
-        cmd["id"] = (int) result.error_code();
-        cmd["msg"] = findError(result.error_code()).message;
-        if(result.is_permission_error())
-            cmd["failed_permid"] = result.permission_id();
+        case command_result_type::bulked: {
+            auto bulks = result.bulks();
+            command.reserve_bulks(bulks->size());
+            for(size_t index{0}; index < bulks->size(); index++) {
+                auto& entry = bulks->at(index);
+                switch (entry.type()) {
+                    case command_result_type::error:
+                        write_command_result_error(command.bulk(index), entry);
+                        break;
+                    case command_result_type::detailed:
+                        write_command_result_detailed(command.bulk(index), entry);
+                        break;
+                    case command_result_type::bulked:
+                        assert(false);
+                        break;
+                }
+            }
+            if(bulks->empty()) {
+                logWarning(this->getServerId(), "{} Trying to send empty error bulk.", CLIENT_STR_LOG_PREFIX_(this));
+                command.put_unchecked(0, "id", (uint32_t) error::ok);
+                command.put_unchecked(0, "msg", findError(error::ok).message);
+            }
+            break;
+        }
+        default:
+            assert(false);
+            break;
     }
 
-    if(retCode.length() > 0)
-        cmd["return_code"] = retCode;
+    if(!retCode.empty())
+        command.put_unchecked(0, "return_code", retCode);
 
-    this->sendCommand(cmd);
+    this->sendCommand(command);
     return true;
 }
 
@@ -630,12 +675,7 @@ inline void send_channels(ConnectedClient* client, ChannelIT begin, const Channe
             break;
     }
 
-    if(dynamic_cast<VoiceClient*>(client)) {
-        auto vc = dynamic_cast<VoiceClient*>(client);
-        vc->sendCommand0(builder.build(), false, true); /* we need to process this command directly so it will be processed before the channellistfinished stuff */
-    } else {
-        client->sendCommand(builder);
-    }
+    client->sendCommand(builder);
     if(begin != end)
         send_channels(client, begin, end, override_orderid);
 }
@@ -739,17 +779,14 @@ void ConnectedClient::tick(const std::chrono::system_clock::time_point &time) {
     }
 
 
-    if(this->last_statistics_tick + seconds(5) < time) {
-        this->last_statistics_tick = time;
-        this->connectionStatistics->tick();
-    }
+    this->connectionStatistics->tick();
 }
 
 void ConnectedClient::sendServerInit() {
     Command command("initserver");
 
     for(const auto& prop : this->server->properties().list_properties(property::FLAG_SERVER_VIEW, this->getType() == CLIENT_TEAMSPEAK ? property::FLAG_NEW : (uint16_t) 0)) {
-        command[prop.type().name] = prop.value();
+        command[std::string{prop.type().name}] = prop.value();
     }
     command["virtualserver_maxclients"] = 32;
 
@@ -779,11 +816,7 @@ void ConnectedClient::sendServerInit() {
     command["pv"] = 6; //Protocol version
     command["acn"] = this->getDisplayName();
     command["aclid"] = this->getClientId();
-    if(dynamic_cast<VoiceClient*>(this)) {
-        dynamic_cast<VoiceClient*>(this)->sendCommand0(command.build(), false, true); /* process it directly so the order for the channellist entries is ensured. (First serverinit then everything else) */
-    } else {
-        this->sendCommand(command);
-    }
+    this->sendCommand(command);
 }
 
 bool ConnectedClient::handleCommandFull(Command& cmd, bool disconnectOnFail) {
@@ -795,14 +828,14 @@ bool ConnectedClient::handleCommandFull(Command& cmd, bool disconnectOnFail) {
 
     command_result result;
     try {
-        result = this->handleCommand(cmd);
+        result.reset(this->handleCommand(cmd));
     } catch(invalid_argument& ex){
         logWarning(this->getServerId(), "{}[Command] Failed to handle command. Received invalid argument exception: {}", CLIENT_STR_LOG_PREFIX, ex.what());
         if(disconnectOnFail) {
             this->disconnect("Invalid argument (" + string(ex.what()) + ")");
             return false;
         } else {
-            result = command_result{error::parameter_convert};
+            result.reset(command_result{error::parameter_convert, ex.what()});
         }
     } catch (exception& ex) {
         logWarning(this->getServerId(), "{}[Command] Failed to handle command. Received exception with message: {}", CLIENT_STR_LOG_PREFIX, ex.what());
@@ -810,7 +843,7 @@ bool ConnectedClient::handleCommandFull(Command& cmd, bool disconnectOnFail) {
             this->disconnect("Error while command handling (" + string(ex.what()) + ")!");
             return false;
         } else {
-            result = command_result{error::vs_critical};
+            result.reset(command_result{error::vs_critical});
         }
     } catch (...) {
         this->disconnect("Error while command handling! (unknown)");
@@ -818,7 +851,7 @@ bool ConnectedClient::handleCommandFull(Command& cmd, bool disconnectOnFail) {
     }
 
     bool generateReturnStatus = false;
-    if(result.error_code() != error::ok || this->getType() == ClientType::CLIENT_QUERY){
+    if(result.has_error() || this->getType() == ClientType::CLIENT_QUERY){
         generateReturnStatus = true;
     } else if(cmd["return_code"].size() > 0) {
         generateReturnStatus = !cmd["return_code"].string().empty();
@@ -827,7 +860,7 @@ bool ConnectedClient::handleCommandFull(Command& cmd, bool disconnectOnFail) {
     if(generateReturnStatus)
         this->notifyError(result, cmd["return_code"].size() > 0 ? cmd["return_code"].first().as<std::string>() : "");
 
-    if(result.error_code() != error::ok && this->state == ConnectionState::INIT_HIGH)
+    if(result.has_error() && this->state == ConnectionState::INIT_HIGH)
         this->close_connection(system_clock::now()); //Disconnect now
 
     for (const auto& handler : postCommandHandler)
@@ -841,7 +874,7 @@ bool ConnectedClient::handleCommandFull(Command& cmd, bool disconnectOnFail) {
         else
             logWarning(this->getServerId(), "Command handling of command {} needs {}ms.", cmd.command(), duration_cast<milliseconds>(end - start).count());
     }
-    result.release_details();
+    result.release_data();
     return true;
 }
 

server/src/client/ConnectedClient.h

@@ -135,7 +135,7 @@ namespace ts {
                 virtual bool notifyClientPoke(std::shared_ptr<ConnectedClient> invoker, std::string msg);
                 virtual bool notifyClientUpdated(
                         const std::shared_ptr<ConnectedClient> &,
-                        const std::deque<std::shared_ptr<property::PropertyDescription>> &,
+                        const std::deque<const property::PropertyDescription*> &,
                         bool lock_channel_tree
                 ); /* invalid client id causes error: invalid clientID */
 
@@ -326,7 +326,6 @@ namespace ts {
                 std::chrono::system_clock::time_point lastOnlineTimestamp;
                 std::chrono::system_clock::time_point lastTransfareTimestamp;
                 std::chrono::system_clock::time_point idleTimestamp;
-                std::chrono::system_clock::time_point last_statistics_tick;
 
                 struct {
                     std::mutex lock;
@@ -634,18 +633,20 @@ namespace ts {
 
         template <typename T>
         struct ConnectedLockedClient {
+            ConnectedLockedClient() {}
             explicit ConnectedLockedClient(std::shared_ptr<T> client) : client{std::move(client)} {
                 if(this->client)
                     this->connection_lock = this->client->require_connected_state();
             }
+            explicit ConnectedLockedClient(ConnectedLockedClient&& client) : client{std::move(client.client)}, connection_lock{std::move(client.connection_lock)} { }
 
-            inline ConnectedLockedClient<T> &operator=(const ConnectedLockedClient& other) {
+            inline ConnectedLockedClient &operator=(const ConnectedLockedClient& other) {
                 this->client = other.client;
                 if(other)
                     this->connection_lock = std::shared_lock{*other.connection_lock.mutex()}; /* if the other is true (state locked & client) than we could easily acquire a shared lock */
             }
 
-            inline ConnectedLockedClient<T> &operator=(ConnectedLockedClient&& other) {
+            inline ConnectedLockedClient &operator=(ConnectedLockedClient&& other) {
                 this->client = std::move(other.client);
                 this->connection_lock = std::move(other.connection_lock);
             }

server/src/client/ConnectedClientNotifyHandler.cpp

@@ -3,7 +3,7 @@
 #include <algorithm>
 #include "ConnectedClient.h"
 #include "voice/VoiceClient.h"
-#include "../server/file/FileServer.h"
+#include "src/server/file/LocalFileServer.h"
 #include "../server/VoiceServer.h"
 #include "../InstanceHandler.h"
 #include "../server/QueryServer.h"
@@ -60,7 +60,7 @@ bool ConnectedClient::notifyServerGroupList() {
             cmd[index]["sgid"] = group->groupId();
         }
         for (const auto &prop : group->properties().list_properties(property::FLAG_GROUP_VIEW, this->getType() == CLIENT_TEAMSPEAK ? property::FLAG_NEW : (uint16_t) 0))
-            cmd[index][prop.type().name] = prop.value();
+            cmd[index][std::string{prop.type().name}] = prop.value();
 
 
         auto modify_power = group->permissions()->permission_value_flagged(permission::i_displayed_group_needed_modify_power);
@@ -186,7 +186,7 @@ bool ConnectedClient::notifyChannelGroupList() {
             cmd[index]["sgid"] = group->groupId();
         }
         for (auto &prop : group->properties().list_properties(property::FLAG_GROUP_VIEW, this->getType() == CLIENT_TEAMSPEAK ? property::FLAG_NEW : (uint16_t) 0))
-            cmd[index][prop.type().name] = prop.value();
+            cmd[index][std::string{prop.type().name}] = prop.value();
 
 
         auto modify_power = group->permissions()->permission_value_flagged(permission::i_displayed_group_needed_modify_power);
@@ -271,108 +271,116 @@ bool ConnectedClient::notifyClientChannelGroupChanged(
 }
 
 bool ConnectedClient::notifyConnectionInfo(const shared_ptr<ConnectedClient> &target, const shared_ptr<ConnectionInfoData> &info) {
-    Command notify("notifyconnectioninfo");
-    notify["clid"] = target->getClientId();
+    command_builder notify{"notifyconnectioninfo"};
+    auto bulk = notify.bulk(0);
+    bulk.put_unchecked("clid", target->getClientId());
 
     auto not_set = this->getType() == CLIENT_TEAMSPEAK ? 0 : -1;
     /* we deliver data to the web client as well, because its a bit dump :D */
     if(target->getClientId() != this->getClientId()) {
-        auto report = target->connectionStatistics->full_report();
+        auto file_stats = target->connectionStatistics->file_stats();
 
         /* default values which normally sets the client */
-        notify["connection_bandwidth_received_last_minute_control"] = not_set;
-        notify["connection_bandwidth_received_last_minute_keepalive"] = not_set;
-        notify["connection_bandwidth_received_last_minute_speech"] = not_set;
-        notify["connection_bandwidth_received_last_second_control"] = not_set;
-        notify["connection_bandwidth_received_last_second_keepalive"] = not_set;
-        notify["connection_bandwidth_received_last_second_speech"] = not_set;
+        bulk.put_unchecked(property::CONNECTION_BANDWIDTH_RECEIVED_LAST_MINUTE_CONTROL, not_set);
+        bulk.put_unchecked(property::CONNECTION_BANDWIDTH_RECEIVED_LAST_MINUTE_KEEPALIVE, not_set);
+        bulk.put_unchecked(property::CONNECTION_BANDWIDTH_RECEIVED_LAST_MINUTE_SPEECH, not_set);
+        bulk.put_unchecked(property::CONNECTION_BANDWIDTH_RECEIVED_LAST_SECOND_CONTROL, not_set);
+        bulk.put_unchecked(property::CONNECTION_BANDWIDTH_RECEIVED_LAST_SECOND_KEEPALIVE, not_set);
+        bulk.put_unchecked(property::CONNECTION_BANDWIDTH_RECEIVED_LAST_SECOND_SPEECH, not_set);
 
-        notify["connection_bandwidth_sent_last_minute_control"] = not_set;
-        notify["connection_bandwidth_sent_last_minute_keepalive"] = not_set;
-        notify["connection_bandwidth_sent_last_minute_speech"] = not_set;
-        notify["connection_bandwidth_sent_last_second_control"] = not_set;
-        notify["connection_bandwidth_sent_last_second_keepalive"] = not_set;
-        notify["connection_bandwidth_sent_last_second_speech"] = not_set;
+        bulk.put_unchecked(property::CONNECTION_BANDWIDTH_SENT_LAST_MINUTE_CONTROL, not_set);
+        bulk.put_unchecked(property::CONNECTION_BANDWIDTH_SENT_LAST_MINUTE_KEEPALIVE, not_set);
+        bulk.put_unchecked(property::CONNECTION_BANDWIDTH_SENT_LAST_MINUTE_SPEECH, not_set);
+        bulk.put_unchecked(property::CONNECTION_BANDWIDTH_SENT_LAST_SECOND_CONTROL, not_set);
+        bulk.put_unchecked(property::CONNECTION_BANDWIDTH_SENT_LAST_SECOND_KEEPALIVE, not_set);
+        bulk.put_unchecked(property::CONNECTION_BANDWIDTH_SENT_LAST_SECOND_SPEECH, not_set);
 
         /* its flipped here because the report is out of the clients view */
-        notify["connection_bytes_received_control"] = not_set;
-        notify["connection_bytes_received_keepalive"] = not_set;
-        notify["connection_bytes_received_speech"] = not_set;
-        notify["connection_bytes_sent_control"] = not_set;
-        notify["connection_bytes_sent_keepalive"] = not_set;
-        notify["connection_bytes_sent_speech"] = not_set;
+        bulk.put_unchecked(property::CONNECTION_BYTES_RECEIVED_CONTROL, not_set);
+        bulk.put_unchecked(property::CONNECTION_BYTES_RECEIVED_KEEPALIVE, not_set);
+        bulk.put_unchecked(property::CONNECTION_BYTES_RECEIVED_SPEECH, not_set);
+        bulk.put_unchecked(property::CONNECTION_BYTES_SENT_CONTROL, not_set);
+        bulk.put_unchecked(property::CONNECTION_BYTES_SENT_KEEPALIVE, not_set);
+        bulk.put_unchecked(property::CONNECTION_BYTES_SENT_SPEECH, not_set);
 
         /* its flipped here because the report is out of the clients view */
-        notify["connection_packets_received_control"] = not_set;
-        notify["connection_packets_received_keepalive"] = not_set;
-        notify["connection_packets_received_speech"] = not_set;
-        notify["connection_packets_sent_control"] = not_set;
-        notify["connection_packets_sent_keepalive"] = not_set;
-        notify["connection_packets_sent_speech"] = not_set;
+        bulk.put_unchecked(property::CONNECTION_PACKETS_RECEIVED_CONTROL, not_set);
+        bulk.put_unchecked(property::CONNECTION_PACKETS_RECEIVED_KEEPALIVE, not_set);
+        bulk.put_unchecked(property::CONNECTION_PACKETS_RECEIVED_SPEECH, not_set);
+        bulk.put_unchecked(property::CONNECTION_PACKETS_SENT_CONTROL, not_set);
+        bulk.put_unchecked(property::CONNECTION_PACKETS_SENT_KEEPALIVE, not_set);
+        bulk.put_unchecked(property::CONNECTION_PACKETS_SENT_SPEECH, not_set);
 
-        notify["connection_server2client_packetloss_control"] = not_set;
-        notify["connection_server2client_packetloss_keepalive"] = not_set;
-        notify["connection_server2client_packetloss_speech"] = not_set;
-        notify["connection_server2client_packetloss_total"] = not_set;
+        bulk.put_unchecked(property::CONNECTION_SERVER2CLIENT_PACKETLOSS_CONTROL, not_set);
+        bulk.put_unchecked(property::CONNECTION_SERVER2CLIENT_PACKETLOSS_KEEPALIVE, not_set);
+        bulk.put_unchecked(property::CONNECTION_SERVER2CLIENT_PACKETLOSS_SPEECH, not_set);
+        bulk.put_unchecked(property::CONNECTION_SERVER2CLIENT_PACKETLOSS_TOTAL, not_set);
 
-        notify["connection_ping"] = 0;
-        notify["connection_ping_deviation"] = 0;
+        bulk.put_unchecked(property::CONNECTION_CLIENT2SERVER_PACKETLOSS_SPEECH, not_set);
+        bulk.put_unchecked(property::CONNECTION_CLIENT2SERVER_PACKETLOSS_KEEPALIVE, not_set);
+        bulk.put_unchecked(property::CONNECTION_CLIENT2SERVER_PACKETLOSS_CONTROL, not_set);
+        bulk.put_unchecked(property::CONNECTION_CLIENT2SERVER_PACKETLOSS_TOTAL, not_set);
 
-        notify["connection_connected_time"] = 0;
-        notify["connection_idle_time"] = 0;
+        bulk.put_unchecked(property::CONNECTION_PING, 0);
+        bulk.put_unchecked(property::CONNECTION_PING_DEVIATION, 0);
+
+        bulk.put_unchecked(property::CONNECTION_CONNECTED_TIME, 0);
+        bulk.put_unchecked(property::CONNECTION_IDLE_TIME, 0);
 
         /* its flipped here because the report is out of the clients view */
-        notify["connection_filetransfer_bandwidth_sent"] = report.file_bytes_received;
-        notify["connection_filetransfer_bandwidth_received"] = report.file_bytes_sent;
+        bulk.put_unchecked(property::CONNECTION_FILETRANSFER_BANDWIDTH_SENT, file_stats.bytes_received);
+        bulk.put_unchecked(property::CONNECTION_FILETRANSFER_BANDWIDTH_RECEIVED, file_stats.bytes_sent);
     }
 
     if(info) {
-        for(const auto& elm : info->properties) {
-            notify[elm.first] = elm.second;
-        }
+        for(const auto& [key, value] : info->properties)
+            bulk.put(key, value);
     } else {
-        //Fill in some server stuff
-        if(dynamic_pointer_cast<VoiceClient>(target))
-            notify["connection_ping"] = floor<milliseconds>(dynamic_pointer_cast<VoiceClient>(target)->calculatePing()).count();
+        //Fill in what we can, else we trust the client
+        if(target->getType() == ClientType::CLIENT_TEASPEAK || target->getType() == ClientType::CLIENT_TEAMSPEAK || target->getType() == ClientType::CLIENT_WEB) {
+            auto& stats = target->connectionStatistics->total_stats();
+            /* its flipped here because the report is out of the clients view */
+            bulk.put(property::CONNECTION_BYTES_RECEIVED_CONTROL, stats.connection_bytes_received[stats::ConnectionStatistics::category::COMMAND]);
+            bulk.put(property::CONNECTION_BYTES_RECEIVED_KEEPALIVE, stats.connection_bytes_received[stats::ConnectionStatistics::category::KEEP_ALIVE]);
+            bulk.put(property::CONNECTION_BYTES_RECEIVED_SPEECH, stats.connection_bytes_received[stats::ConnectionStatistics::category::VOICE]);
+            bulk.put(property::CONNECTION_BYTES_SENT_CONTROL, stats.connection_bytes_sent[stats::ConnectionStatistics::category::COMMAND]);
+            bulk.put(property::CONNECTION_BYTES_SENT_KEEPALIVE, stats.connection_bytes_sent[stats::ConnectionStatistics::category::KEEP_ALIVE]);
+            bulk.put(property::CONNECTION_BYTES_SENT_SPEECH, stats.connection_bytes_sent[stats::ConnectionStatistics::category::VOICE]);
+
+            /* its flipped here because the report is out of the clients view */
+            bulk.put(property::CONNECTION_PACKETS_RECEIVED_CONTROL, stats.connection_packets_received[stats::ConnectionStatistics::category::COMMAND]);
+            bulk.put(property::CONNECTION_PACKETS_RECEIVED_KEEPALIVE, stats.connection_packets_received[stats::ConnectionStatistics::category::KEEP_ALIVE]);
+            bulk.put(property::CONNECTION_PACKETS_RECEIVED_SPEECH, stats.connection_packets_received[stats::ConnectionStatistics::category::VOICE]);
+            bulk.put(property::CONNECTION_PACKETS_SENT_CONTROL, stats.connection_packets_sent[stats::ConnectionStatistics::category::COMMAND]);
+            bulk.put(property::CONNECTION_PACKETS_SENT_KEEPALIVE, stats.connection_packets_sent[stats::ConnectionStatistics::category::KEEP_ALIVE]);
+            bulk.put(property::CONNECTION_PACKETS_SENT_SPEECH, stats.connection_packets_sent[stats::ConnectionStatistics::category::VOICE]);
+        }
+    }
+    if(auto vc = dynamic_pointer_cast<VoiceClient>(target); vc) {
+        bulk.put(property::CONNECTION_PING, floor<milliseconds>(vc->current_ping()).count());
+        bulk.put(property::CONNECTION_PING_DEVIATION, vc->current_ping_deviation());
+    }
 #ifdef COMPILE_WEB_CLIENT
-        else if(dynamic_pointer_cast<WebClient>(target))
-            notify["connection_ping"] = floor<milliseconds>(dynamic_pointer_cast<WebClient>(target)->client_ping()).count();
+    else if(dynamic_pointer_cast<WebClient>(target))
+        bulk.put(property::CONNECTION_PING, floor<milliseconds>(dynamic_pointer_cast<WebClient>(target)->client_ping()).count());
 #endif
 
-        if(target->getType() == ClientType::CLIENT_TEASPEAK || target->getType() == ClientType::CLIENT_TEAMSPEAK || target->getType() == ClientType::CLIENT_WEB) {
-            auto report = target->connectionStatistics->full_report();
-
-            /* its flipped here because the report is out of the clients view */
-            notify["connection_bytes_received_control"] = report.connection_bytes_sent[stats::ConnectionStatistics::category::COMMAND];
-            notify["connection_bytes_received_keepalive"] = report.connection_bytes_sent[stats::ConnectionStatistics::category::ACK];
-            notify["connection_bytes_received_speech"] = report.connection_bytes_sent[stats::ConnectionStatistics::category::VOICE];
-            notify["connection_bytes_sent_control"] = report.connection_bytes_sent[stats::ConnectionStatistics::category::COMMAND];
-            notify["connection_bytes_sent_keepalive"] = report.connection_bytes_sent[stats::ConnectionStatistics::category::ACK];
-            notify["connection_bytes_sent_speech"] = report.connection_bytes_sent[stats::ConnectionStatistics::category::VOICE];
-
-            /* its flipped here because the report is out of the clients view */
-            notify["connection_packets_received_control"] = report.connection_packets_sent[stats::ConnectionStatistics::category::COMMAND];
-            notify["connection_packets_received_keepalive"] = report.connection_packets_sent[stats::ConnectionStatistics::category::ACK];
-            notify["connection_packets_received_speech"] = report.connection_packets_sent[stats::ConnectionStatistics::category::VOICE];
-            notify["connection_packets_sent_control"] = report.connection_packets_sent[stats::ConnectionStatistics::category::COMMAND];
-            notify["connection_packets_sent_keepalive"] = report.connection_packets_sent[stats::ConnectionStatistics::category::ACK];
-            notify["connection_packets_sent_speech"] = report.connection_packets_sent[stats::ConnectionStatistics::category::VOICE];
-        }
+    if(auto vc = dynamic_pointer_cast<VoiceClient>(target); vc){
+        auto& calculator = vc->connection->packet_statistics();
+        auto report = calculator.loss_report();
+        bulk.put(property::CONNECTION_CLIENT2SERVER_PACKETLOSS_SPEECH, std::to_string(report.voice_loss()));
+        bulk.put(property::CONNECTION_CLIENT2SERVER_PACKETLOSS_KEEPALIVE, std::to_string(report.keep_alive_loss()));
+        bulk.put(property::CONNECTION_CLIENT2SERVER_PACKETLOSS_CONTROL, std::to_string(report.control_loss()));
+        bulk.put(property::CONNECTION_CLIENT2SERVER_PACKETLOSS_TOTAL, std::to_string(report.total_loss()));
     }
 
     if(target->getClientId() == this->getClientId() || permission::v2::permission_granted(1, this->calculate_permission(permission::b_client_remoteaddress_view, this->getChannelId()))) {
-        notify["connection_client_ip"] = target->getLoggingPeerIp();
-        notify["connection_client_port"] = target->getPeerPort();
+        bulk.put(property::CONNECTION_CLIENT_IP, target->getLoggingPeerIp());
+        bulk.put(property::CONNECTION_CLIENT_PORT, target->getPeerPort());
     }
 
-    //Needs to be filled out
-    notify["connection_client2server_packetloss_speech"] = not_set;
-    notify["connection_client2server_packetloss_keepalive"] = not_set;
-    notify["connection_client2server_packetloss_control"] = not_set;
-    notify["connection_client2server_packetloss_total"] = not_set;
-
-    notify["connection_connected_time"] = chrono::duration_cast<chrono::milliseconds>(chrono::system_clock::now() - target->connectTimestamp).count();
-    notify["connection_idle_time"] = chrono::duration_cast<chrono::milliseconds>(chrono::system_clock::now() - target->idleTimestamp).count();
+    bulk.put(property::CONNECTION_CONNECTED_TIME, chrono::duration_cast<chrono::milliseconds>(chrono::system_clock::now() - target->connectTimestamp).count());
+    bulk.put(property::CONNECTION_IDLE_TIME, chrono::duration_cast<chrono::milliseconds>(chrono::system_clock::now() - target->idleTimestamp).count());
     this->sendCommand(notify);
     return true;
 }
@@ -404,7 +412,7 @@ bool ConnectedClient::notifyClientMoved(const shared_ptr<ConnectedClient> &clien
     return true;
 }
 
-bool ConnectedClient::notifyClientUpdated(const std::shared_ptr<ConnectedClient> &client, const deque<shared_ptr<property::PropertyDescription>> &props, bool lock) {
+bool ConnectedClient::notifyClientUpdated(const std::shared_ptr<ConnectedClient> &client, const deque<const property::PropertyDescription*> &props, bool lock) {
     shared_lock channel_lock(this->channel_lock, defer_lock);
     if(lock)
         channel_lock.lock();
@@ -420,7 +428,7 @@ bool ConnectedClient::notifyClientUpdated(const std::shared_ptr<ConnectedClient>
     Command response("notifyclientupdated");
     response["clid"] = client_id;
     for (const auto &prop : props) {
-        if(lastOnlineTimestamp.time_since_epoch().count() > 0 && (prop->property_index == property::CLIENT_TOTAL_ONLINE_TIME || prop->property_index == property::CLIENT_MONTH_ONLINE_TIME))
+        if(lastOnlineTimestamp.time_since_epoch().count() > 0 && (*prop == property::CLIENT_TOTAL_ONLINE_TIME || *prop == property::CLIENT_MONTH_ONLINE_TIME))
             response[prop->name] = client->properties()[prop].as<int64_t>() + duration_cast<seconds>(system_clock::now() - client->lastOnlineTimestamp).count();
         else
             response[prop->name] = client->properties()[prop].value();
@@ -650,7 +658,7 @@ bool ConnectedClient::notifyClientEnterView(const std::deque<std::shared_ptr<Con
 
         this->visibleClients.push_back(client);
         for (const auto &elm : client->properties()->list_properties(property::FLAG_CLIENT_VIEW, this->getType() == CLIENT_TEAMSPEAK ? property::FLAG_NEW : (uint16_t) 0)) {
-            cmd[index][elm.type().name] = elm.value();
+            cmd[index][std::string{elm.type().name}] = elm.value();
         }
 
         index++;
@@ -678,14 +686,14 @@ bool ConnectedClient::notifyChannelEdited(
 
     Command notify("notifychanneledited");
     for(auto prop : properties) {
-        const auto& prop_info = property::impl::info(prop);
+        const auto& prop_info = property::describe(prop);
 
         if(prop == property::CHANNEL_ORDER)
-            notify[prop_info->name] = v_channel->previous_channel;
+            notify[prop_info.name] = v_channel->previous_channel;
         else if(prop == property::CHANNEL_DESCRIPTION) {
             send_description_change = true;
         } else {
-            notify[prop_info->name] = channel->properties()[prop].as<string>();
+            notify[prop_info.name] = channel->properties()[prop].as<string>();
         }
     }
 

server/src/client/ConnectedClientTextCommandHandler.cpp

@@ -158,8 +158,8 @@ bool ConnectedClient::handle_text_command(
         if (TARG(0, "create")) {
             Command cmd("");
             auto result = this->handleCommandMusicBotCreate(cmd);
-            if(result.error_code()) {
-                result.release_details();
+            if(result.has_error()) {
+                result.release_data();
                 HANDLE_CMD_ERROR("Failed to create music bot");
                 return true;
             }
@@ -220,9 +220,9 @@ bool ConnectedClient::handle_text_command(
             Command cmd("");
             cmd["client_nickname"] = ss.str();
             auto result = this->handleCommandClientEdit(cmd, bot);
-            if(result.error_code()) {
+            if(result.has_error()) {
                 HANDLE_CMD_ERROR("Failed to rename bot");
-                result.release_details();
+                result.release_data();
                 return true;
             }
             send_message(serverInstance->musicRoot(), "Name successfully changed!");
@@ -486,7 +486,7 @@ bool ConnectedClient::handle_text_command(
                     for(const auto& property : bot->properties()->list_properties(~0)) {
                         if(find(editable_properties.begin(), editable_properties.end(), property.type().name) == editable_properties.end()) continue;
 
-                        send_message(bot, " - " + property.type().name + " = " + property.value() + " " + (property.default_value() == property.value() ? "(default)" : ""));
+                        send_message(bot, " - " + std::string{property.type().name} + " = " + property.value() + " " + (property.default_value() == property.value() ? "(default)" : ""));
                     }
                 } else if(arguments.size() < 4) {
                     if(find(editable_properties.begin(), editable_properties.end(), arguments[2]) == editable_properties.end()) {
@@ -494,23 +494,23 @@ bool ConnectedClient::handle_text_command(
                         return true;
                     }
 
-                    const std::shared_ptr<property::PropertyDescription> &property_info = property::info<property::ClientProperties>(arguments[2]);
-                    if(!property_info || property_info->type_property == property::PROP_TYPE_UNKNOWN || property_info->property_index == property::CLIENT_UNDEFINED) {
+                    const auto &property_info = property::find<property::ClientProperties>(arguments[2]);
+                    if(property_info.is_undefined()) {
                         send_message(bot, "Unknown property " + arguments[2] + ".");
                         return true;
                     }
 
-                    auto prop = bot->properties()[(property::ClientProperties) property_info->property_index];
-                    send_message(bot, "Bot property " + property_info->name + " = " + prop.value() + " " + (property_info->default_value == prop.value() ? "(default)" : ""));
+                    auto prop = bot->properties()[(property::ClientProperties) property_info.property_index];
+                    send_message(bot, "Bot property " + std::string{property_info.name} + " = " + prop.value() + " " + (property_info.default_value == prop.value() ? "(default)" : ""));
                     return true;
                 } else {
                     Command cmd("");
                     JOIN_ARGS(value, 3);
                     cmd[arguments[2]] = value;
                     auto result = this->handleCommandClientEdit(cmd, bot);
-                    if(result.error_code()) {
+                    if(result.has_error()) {
                         HANDLE_CMD_ERROR("Failed to change bot property");
-                        result.release_details();
+                        result.release_data();
                         return true;
                     }
                     send_message(serverInstance->musicRoot(), "Property successfully changed!");
@@ -527,36 +527,36 @@ bool ConnectedClient::handle_text_command(
                 if(arguments.size() < 3) {
                     send_message(bot, "Playlist properties:");
                     for(const auto& property : playlist->properties().list_properties(property::FLAG_PLAYLIST_VARIABLE)) {
-                        send_message(bot, " - " + property.type().name + " = " + property.value() + " " + (property.default_value() == property.value() ? "(default)" : ""));
+                        send_message(bot, " - " + std::string{property.type().name} + " = " + property.value() + " " + (property.default_value() == property.value() ? "(default)" : ""));
                     }
                 } else if(arguments.size() < 4) {
-                    const std::shared_ptr<property::PropertyDescription> &property_info = property::info<property::PlaylistProperties>(arguments[2]);
-                    if(!property_info || property_info->type_property == property::PROP_TYPE_UNKNOWN || property_info->property_index == property::PLAYLIST_UNDEFINED) {
+                    const auto &property_info = property::find<property::PlaylistProperties>(arguments[2]);
+                    if(property_info.is_undefined()) {
                         send_message(bot, "Unknown property " + arguments[2] + ".");
                         return true;
                     }
 
-                    auto prop = playlist->properties()[(property::PlaylistProperties) property_info->property_index];
-                    send_message(bot, "Bot property " + property_info->name + " = " + prop.value() + " " + (property_info->default_value == prop.value() ? "(default)" : ""));
+                    auto prop = playlist->properties()[(property::PlaylistProperties) property_info.property_index];
+                    send_message(bot, "Bot property " + std::string{property_info.name} + " = " + prop.value() + " " + (property_info.default_value == prop.value() ? "(default)" : ""));
                 } else {
-                    const std::shared_ptr<property::PropertyDescription> &property_info = property::info<property::PlaylistProperties>(arguments[2]);
-                    if(!property_info || property_info->type_property == property::PROP_TYPE_UNKNOWN || property_info->property_index == property::PLAYLIST_UNDEFINED) {
+                    const auto &property_info = property::find<property::PlaylistProperties>(arguments[2]);
+                    if(property_info.is_undefined()) {
                         send_message(bot, "Unknown property " + arguments[2] + ".");
                         return true;
                     }
 
                     JOIN_ARGS(value, 3);
-                    if(!property_info->validate_input(value)) {
+                    if(!property_info.validate_input(value)) {
                         send_message(bot, "Please enter a valid value!");
                         return true;
                     }
 
-                    if((property_info->flags & property::FLAG_USER_EDITABLE) == 0) {
+                    if((property_info.flags & property::FLAG_USER_EDITABLE) == 0) {
                         send_message(bot, "This property isnt changeable!");
                         return true;
                     }
 
-                    playlist->properties()[(property::PlaylistProperties) property_info->property_index] = value;
+                    playlist->properties()[(property::PlaylistProperties) property_info.property_index] = value;
                     send_message(bot, "Property successfully changed");
                     return true;
                 }
@@ -641,9 +641,42 @@ bool ConnectedClient::handle_text_command(
 
                 auto id = vc->getConnection()->getPacketIdManager().currentPacketId(type);
                 auto gen = vc->getConnection()->getPacketIdManager().generationId(type);
+                auto& genestis = vc->getConnection()->get_incoming_generation_estimators();
+
                 send_message(_this.lock(), " OUT " + type.name() + " => generation: " + to_string(gen) + " id: " + to_string(id));
-                //auto& buffer = vc->getConnection()->packet_buffers()[type.type()];
-                //send_message(_this.lock(), " IN  " + type.name() + " => generation: " + to_string(buffer.generation(0)) + " id: " + to_string(buffer.current_index()));
+                send_message(_this.lock(), " IN  " + type.name() + " => generation: " + to_string(genestis[type.type()].generation()) + " id: " + to_string(genestis[type.type()].current_packet_id()));
+            }
+            return true;
+        } else if(TARG(0, "ping")) {
+            auto vc = dynamic_pointer_cast<VoiceClient>(_this.lock());
+            if(!vc) return false;
+
+            auto& ack = vc->connection->getAcknowledgeManager();
+            send_message(_this.lock(), "Command retransmission values:");
+            send_message(_this.lock(), " RTO   : " + std::to_string(ack.current_rto()));
+            send_message(_this.lock(), " RTTVAR: " + std::to_string(ack.current_rttvar()));
+            send_message(_this.lock(), " SRTT  : " + std::to_string(ack.current_srtt()));
+            return true;
+        } else if(TARG(0, "sgeneration")) {
+            TLEN(4);
+
+            try {
+                auto type = stol(arguments[1]);
+                auto generation = stol(arguments[2]);
+                auto pid = stol(arguments[3]);
+
+                auto vc = dynamic_pointer_cast<VoiceClient>(_this.lock());
+                if(!vc) return false;
+
+                auto& genestis = vc->getConnection()->get_incoming_generation_estimators();
+                if(type >= genestis.size()) {
+                    send_message(_this.lock(), "Invalid type");
+                    return true;
+                }
+                genestis[type].set_last_state(pid, generation);
+            } catch(std::exception& ex) {
+                send_message(_this.lock(), "Failed to parse argument");
+                return true;
             }
             return true;
         } else if(TARG(0, "disconnect")) {

server/src/client/DataClient.cpp

@@ -4,7 +4,7 @@
 #include <misc/hex.h>
 #include "DataClient.h"
 #include "ConnectedClient.h"
-#include "src/server/file/FileServer.h"
+#include "src/server/file/LocalFileServer.h"
 #include "src/InstanceHandler.h"
 #include "misc/base64.h"
 

server/src/client/DataClient.h

@@ -45,10 +45,17 @@ namespace ts {
                         return std::forward<F>(f)(*handle);
                     }
 
+                    /*
                     template <typename T>
                     ts::PropertyWrapper operator[](T type) {
                         return (*handle)[type];
                     }
+                    */
+
+                    template <typename T>
+                    ts::PropertyWrapper operator[](const T& type) {
+                        return (*handle)[type];
+                    }
                 };
 
                 DataClient(sql::SqlManager*, const std::shared_ptr<VirtualServer>&);

server/src/client/SpeakingClient.cpp

@@ -10,7 +10,6 @@
 #include "SpeakingClient.h"
 #include "src/InstanceHandler.h"
 #include "StringVariable.h"
-#include "src/music/MusicBotManager.h"
 #include "misc/timer.h"
 
 using namespace std::chrono;
@@ -52,6 +51,14 @@ void SpeakingClient::handlePacketVoice(const pipes::buffer_view& data, bool head
         return;
     }
 
+#if 0
+    if(rand() % 10 == 0) {
+        logMessage(0, "Dropping audio packet");
+        return;
+    }
+    logMessage(0, "Received voice: Head: {} Fragmented: {}, length: {}", head, fragmented, data.length());
+#endif
+
     auto current_channel = this->currentChannel;
     if(!current_channel) { return; }
     if(!this->allowedToTalk) { return; }
@@ -65,7 +72,6 @@ void SpeakingClient::handlePacketVoice(const pipes::buffer_view& data, bool head
         if(!speaking_client) return true;
 
         return !speaking_client->shouldReceiveVoice(self);
-
     }), target_clients.end());
     if(target_clients.empty()) {
         return;
@@ -100,9 +106,10 @@ void SpeakingClient::handlePacketVoice(const pipes::buffer_view& data, bool head
         memcpy(&buffer[5], &data[3], data.length() - 3);
     }
 
+    auto bview = pipes::buffer_view{buffer, data.length() + 2};
     for (const auto& client : target_clients) {
         auto speaking_client = static_pointer_cast<SpeakingClient>(client);
-        speaking_client->send_voice_packet(pipes::buffer_view{buffer, data.length() + 2}, flags);
+        speaking_client->send_voice_packet(bview, flags);
     }
 }
 
@@ -114,7 +121,9 @@ enum WhisperType {
     SERVER_GROUP = 0,
     CHANNEL_GROUP = 1,
     CHANNEL_COMMANDER = 2,
-    ALL = 3
+    ALL = 3,
+
+    ECHO_TEXT = 0x10,
 };
 
 enum WhisperTarget {
@@ -174,87 +183,93 @@ void SpeakingClient::handlePacketVoiceWhisper(const pipes::buffer_view& data, bo
 #endif
 
         deque<shared_ptr<SpeakingClient>> available_clients;
-        for(const auto& client : this->server->getClients()) {
-            auto speakingClient = dynamic_pointer_cast<SpeakingClient>(client);
-            if(!speakingClient || client == this) continue;
-            if(!speakingClient->currentChannel) continue;
+        if(type == WhisperType::ECHO_TEXT) {
+            available_clients.push_back(dynamic_pointer_cast<SpeakingClient>(this->ref()));
+        } else {
+            for(const auto& client : this->server->getClients()) {
+                auto speakingClient = dynamic_pointer_cast<SpeakingClient>(client);
+                if(!speakingClient || client == this) continue;
+                if(!speakingClient->currentChannel) continue;
 
-            if(type == WhisperType::ALL) {
-                available_clients.push_back(speakingClient);
-            } else if(type == WhisperType::SERVER_GROUP) {
-                if(type_id == 0)
+                if(type == WhisperType::ALL) {
                     available_clients.push_back(speakingClient);
-                else {
-                    shared_lock client_lock(this->channel_lock);
-                    for(const auto& id : client->cached_server_groups) {
-                        if(id == type_id) {
-                            available_clients.push_back(speakingClient);
-                            break;
+                } else if(type == WhisperType::SERVER_GROUP) {
+                    if(type_id == 0)
+                        available_clients.push_back(speakingClient);
+                    else {
+                        shared_lock client_lock(this->channel_lock);
+                        for(const auto& id : client->cached_server_groups) {
+                            if(id == type_id) {
+                                available_clients.push_back(speakingClient);
+                                break;
+                            }
                         }
                     }
+                } else if(type == WhisperType::CHANNEL_GROUP) {
+                    if(client->cached_channel_group == type_id)
+                        available_clients.push_back(speakingClient);
+                } else if(type == WhisperType::CHANNEL_COMMANDER) {
+                    if(client->properties()[property::CLIENT_IS_CHANNEL_COMMANDER].as<bool>())
+                        available_clients.push_back(speakingClient);
                 }
-            } else if(type == WhisperType::CHANNEL_GROUP) {
-                if(client->cached_channel_group == type_id)
-                    available_clients.push_back(speakingClient);
-            } else if(type == WhisperType::CHANNEL_COMMANDER) {
-                if(client->properties()[property::CLIENT_IS_CHANNEL_COMMANDER].as<bool>())
-                    available_clients.push_back(speakingClient);
             }
-        }
 
-        if(target == WhisperTarget::CHANNEL_CURRENT) {
-            available_clients.erase(std::remove_if(available_clients.begin(), available_clients.end(), [&](const shared_ptr<SpeakingClient>& target) {
-                return target->currentChannel != this->currentChannel;
-            }), available_clients.end());
-        } else if(target == WhisperTarget::CHANNEL_PARENT) {
-            auto current_parent = this->currentChannel->parent();
-            if(!current_parent) return;
 
-            available_clients.erase(std::remove_if(available_clients.begin(), available_clients.end(), [&](const shared_ptr<SpeakingClient>& target) {
-                return target->currentChannel != current_parent;
-            }), available_clients.end());
-        } else if(target == WhisperTarget::CHANNEL_ALL_PARENT) {
-            shared_ptr<BasicChannel> current_parent;
-            {
-                current_parent = this->currentChannel->parent();
+
+            if(target == WhisperTarget::CHANNEL_CURRENT) {
+                available_clients.erase(std::remove_if(available_clients.begin(), available_clients.end(), [&](const shared_ptr<SpeakingClient>& target) {
+                    return target->currentChannel != this->currentChannel;
+                }), available_clients.end());
+            } else if(target == WhisperTarget::CHANNEL_PARENT) {
+                auto current_parent = this->currentChannel->parent();
                 if(!current_parent) return;
+
+                available_clients.erase(std::remove_if(available_clients.begin(), available_clients.end(), [&](const shared_ptr<SpeakingClient>& target) {
+                    return target->currentChannel != current_parent;
+                }), available_clients.end());
+            } else if(target == WhisperTarget::CHANNEL_ALL_PARENT) {
+                shared_ptr<BasicChannel> current_parent;
+                {
+                    current_parent = this->currentChannel->parent();
+                    if(!current_parent) return;
+                }
+                available_clients.erase(std::remove_if(available_clients.begin(), available_clients.end(), [&](const shared_ptr<SpeakingClient>& target) {
+                    auto tmp_parent = current_parent;
+                    while(tmp_parent && tmp_parent != target->currentChannel)
+                        tmp_parent = tmp_parent->parent();
+                    return target->currentChannel != tmp_parent;
+                }), available_clients.end());
+            } else if(target == WhisperTarget::CHANNEL_FAMILY) {
+                shared_ptr<BasicChannel> current = this->currentChannel;
+                available_clients.erase(std::remove_if(available_clients.begin(), available_clients.end(), [&](const shared_ptr<SpeakingClient>& target) {
+                    auto tmp_current = target->currentChannel;
+                    while(tmp_current && tmp_current != current)
+                        tmp_current = tmp_current->parent();
+                    return current != tmp_current;
+                }), available_clients.end());
+            } else if(target == WhisperTarget::CHANNEL_COMPLETE_FAMILY) {
+                shared_ptr<BasicChannel> current = this->currentChannel;
+                while(current && current->parent()) current = current->parent();
+                available_clients.erase(std::remove_if(available_clients.begin(), available_clients.end(), [&](const shared_ptr<SpeakingClient>& target) {
+                    auto tmp_current = target->currentChannel;
+                    while(tmp_current && tmp_current != current)
+                        tmp_current = tmp_current->parent();
+                    return current != tmp_current;
+                }), available_clients.end());
+            } else if(target == WhisperTarget::CHANNEL_SUBCHANNELS) {
+                shared_ptr<BasicChannel> current = this->currentChannel;
+                available_clients.erase(std::remove_if(available_clients.begin(), available_clients.end(), [&](const shared_ptr<SpeakingClient>& target) {
+                    return target->currentChannel->parent() != current;
+                }), available_clients.end());
             }
-            available_clients.erase(std::remove_if(available_clients.begin(), available_clients.end(), [&](const shared_ptr<SpeakingClient>& target) {
-                auto tmp_parent = current_parent;
-                while(tmp_parent && tmp_parent != target->currentChannel)
-                    tmp_parent = tmp_parent->parent();
-                return target->currentChannel != tmp_parent;
-            }), available_clients.end());
-        } else if(target == WhisperTarget::CHANNEL_FAMILY) {
-            shared_ptr<BasicChannel> current = this->currentChannel;
-            available_clients.erase(std::remove_if(available_clients.begin(), available_clients.end(), [&](const shared_ptr<SpeakingClient>& target) {
-                auto tmp_current = target->currentChannel;
-                while(tmp_current && tmp_current != current)
-                    tmp_current = tmp_current->parent();
-                return current != tmp_current;
-            }), available_clients.end());
-        } else if(target == WhisperTarget::CHANNEL_COMPLETE_FAMILY) {
-            shared_ptr<BasicChannel> current = this->currentChannel;
-            while(current && current->parent()) current = current->parent();
-            available_clients.erase(std::remove_if(available_clients.begin(), available_clients.end(), [&](const shared_ptr<SpeakingClient>& target) {
-                auto tmp_current = target->currentChannel;
-                while(tmp_current && tmp_current != current)
-                    tmp_current = tmp_current->parent();
-                return current != tmp_current;
-            }), available_clients.end());
-        } else if(target == WhisperTarget::CHANNEL_SUBCHANNELS) {
-            shared_ptr<BasicChannel> current = this->currentChannel;
-            available_clients.erase(std::remove_if(available_clients.begin(), available_clients.end(), [&](const shared_ptr<SpeakingClient>& target) {
-                return target->currentChannel->parent() != current;
+
+            auto self_lock = this->_this.lock();
+            available_clients.erase(std::remove_if(available_clients.begin(), available_clients.end(), [&](const std::shared_ptr<ConnectedClient>& cl) {
+                auto speakingClient = dynamic_pointer_cast<SpeakingClient>(cl);
+                return !speakingClient->shouldReceiveVoiceWhisper(self_lock);
             }), available_clients.end());
         }
 
-        auto self_lock = this->_this.lock();
-        available_clients.erase(std::remove_if(available_clients.begin(), available_clients.end(), [&](const std::shared_ptr<ConnectedClient>& cl) {
-            auto speakingClient = dynamic_pointer_cast<SpeakingClient>(cl);
-            return !speakingClient->shouldReceiveVoiceWhisper(self_lock);
-        }), available_clients.end());
-
         if(available_clients.empty()) {
             if(update_whisper_error(this->speak_last_no_whisper_target)) {
                 command_result result{error::whisper_no_targets};
@@ -282,7 +297,7 @@ void SpeakingClient::handlePacketVoiceWhisper(const pipes::buffer_view& data, bo
         VoicePacketFlags flags{};
         auto data = pipes::buffer_view(packet_buffer, OUT_WHISPER_PKT_OFFSET + data_length);
         for(const auto& cl : available_clients){
-                cl->send_voice_whisper_packet(data, flags);
+            cl->send_voice_whisper_packet(data, flags);
         }
 
         this->updateSpeak(false, system_clock::now());
@@ -378,7 +393,7 @@ auto regex_wildcard = std::regex(".*");
 
 #define S(x) #x
 #define HWID_REGEX(name, pattern)                           \
-auto regex_hwid_ ##name = [](){                             \
+auto regex_hwid_ ##name = []() noexcept {                   \
     try {                                                   \
         return std::regex(pattern);                         \
     } catch (std::exception& ex) {                          \
@@ -480,13 +495,13 @@ command_result SpeakingClient::handleCommandClientInit(Command& cmd) {
                 }
         }
 
-        const auto &info = property::info<property::ClientProperties>(key);
-        if(*info == property::CLIENT_UNDEFINED) {
+        const auto &info = property::find<property::ClientProperties>(key);
+        if(info.is_undefined()) {
             logError(this->getServerId(), "{} Tried to pass a unknown value {}. Please report this, if you're sure that this key should be known!", CLIENT_STR_LOG_PREFIX, key);
             continue;
             //return {findError("parameter_invalid"), "Unknown property " + key};
         }
-        if(!info->validate_input(cmd[key].as<string>()))
+        if(!info.validate_input(cmd[key].as<string>()))
             return command_result{error::parameter_invalid};
 
         this->properties()[info] = cmd[key].as<std::string>();
@@ -533,37 +548,39 @@ command_result SpeakingClient::handleCommandClientInit(Command& cmd) {
         if(!this->server->verifyServerPassword(cmd["client_server_password"].string(), true))
             return command_result{error::server_invalid_password};
 
-    size_t clones_uid = 0;
-    size_t clones_ip = 0;
-    size_t clones_hwid = 0;
+    if(!config::server::clients::ignore_max_clone_permissions) {
+        size_t clones_uid = 0;
+        size_t clones_ip = 0;
+        size_t clones_hwid = 0;
 
-    auto _own_hwid = this->getHardwareId();
-    this->server->forEachClient([&](const shared_ptr<ConnectedClient>& client) {
-        if(client->getExternalType() != CLIENT_TEAMSPEAK) return;
-        if(client->getUid() == this->getUid())
-            clones_uid++;
-        if(client->getPeerIp() == this->getPeerIp())
-            clones_ip++;
-        if(!_own_hwid.empty() && client->getHardwareId() == _own_hwid)
-            clones_hwid++;
-    });
+        auto _own_hwid = this->getHardwareId();
+        this->server->forEachClient([&](const shared_ptr<ConnectedClient>& client) {
+            if(client->getExternalType() != CLIENT_TEAMSPEAK) return;
+            if(client->getUid() == this->getUid())
+                clones_uid++;
+            if(client->getPeerIp() == this->getPeerIp())
+                clones_ip++;
+            if(!_own_hwid.empty() && client->getHardwareId() == _own_hwid)
+                clones_hwid++;
+        });
 
-    if(clones_uid > 0 && permissions[permission::i_client_max_clones_uid].has_value && !permission::v2::permission_granted(clones_uid, permissions[permission::i_client_max_clones_uid])) {
-        logMessage(this->getServerId(), "{} Disconnecting because there are already {} uid clones connected. (Allowed: {})", CLIENT_STR_LOG_PREFIX, clones_uid, permissions[permission::i_client_max_clones_uid]);
-        return command_result{error:: client_too_many_clones_connected, "too many clones connected (uid)"};
+        if(clones_uid > 0 && permissions[permission::i_client_max_clones_uid].has_value && !permission::v2::permission_granted(clones_uid, permissions[permission::i_client_max_clones_uid])) {
+            logMessage(this->getServerId(), "{} Disconnecting because there are already {} uid clones connected. (Allowed: {})", CLIENT_STR_LOG_PREFIX, clones_uid, permissions[permission::i_client_max_clones_uid]);
+            return command_result{error:: client_too_many_clones_connected, "too many clones connected (uid)"};
+        }
+
+        if(clones_ip > 0 && permissions[permission::i_client_max_clones_ip].has_value && !permission::v2::permission_granted(clones_ip, permissions[permission::i_client_max_clones_ip])) {
+            logMessage(this->getServerId(), "{} Disconnecting because there are already {} ip clones connected. (Allowed: {})", CLIENT_STR_LOG_PREFIX, clones_ip, permissions[permission::i_client_max_clones_ip]);
+            return command_result{error:: client_too_many_clones_connected, "too many clones connected (ip)"};
+        }
+
+        if(clones_hwid > 0 && permissions[permission::i_client_max_clones_hwid].has_value && !permission::v2::permission_granted(clones_hwid, permissions[permission::i_client_max_clones_hwid])) {
+            logMessage(this->getServerId(), "{} Disconnecting because there are already {} hwid clones connected. (Allowed: {})", CLIENT_STR_LOG_PREFIX, clones_hwid, permissions[permission::i_client_max_clones_hwid]);
+            return command_result{error:: client_too_many_clones_connected, "too many clones connected (hwid)"};
+        }
+        TIMING_STEP(timings, "max clones ");
     }
 
-    if(clones_ip > 0 && permissions[permission::i_client_max_clones_ip].has_value && !permission::v2::permission_granted(clones_ip, permissions[permission::i_client_max_clones_ip])) {
-        logMessage(this->getServerId(), "{} Disconnecting because there are already {} ip clones connected. (Allowed: {})", CLIENT_STR_LOG_PREFIX, clones_ip, permissions[permission::i_client_max_clones_ip]);
-        return command_result{error:: client_too_many_clones_connected, "too many clones connected (ip)"};
-    }
-
-    if(clones_hwid > 0 && permissions[permission::i_client_max_clones_hwid].has_value && !permission::v2::permission_granted(clones_hwid, permissions[permission::i_client_max_clones_hwid])) {
-        logMessage(this->getServerId(), "{} Disconnecting because there are already {} hwid clones connected. (Allowed: {})", CLIENT_STR_LOG_PREFIX, clones_hwid, permissions[permission::i_client_max_clones_hwid]);
-        return command_result{error:: client_too_many_clones_connected, "too many clones connected (hwid)"};
-    }
-    TIMING_STEP(timings, "max clones ");
-
     auto banEntry = this->resolveActiveBan(this->getPeerIp());
     if(banEntry) {
         logMessage(this->getServerId(), "{} Disconnecting while init because of ban record. Record id {} at server {}",
@@ -722,7 +739,7 @@ void SpeakingClient::processJoin() {
     if(!ref_server->assignDefaultChannel(this->ref(), false)) {
         auto result = command_result{error::vs_critical, "Could not assign default channel!"};
         this->notifyError(result);
-        result.release_details();
+        result.release_data();
         this->close_connection(system_clock::now() + seconds(1));
         return;
     }
@@ -743,7 +760,7 @@ void SpeakingClient::processJoin() {
 
         unique_lock server_channel_lock(this->server->channel_tree_lock);
         this->server->client_move(this->ref(), channel, nullptr, "", ViewReasonId::VREASON_USER_ACTION, false, server_channel_lock);
-        this->subscribeChannel({this->currentChannel}, false, true);
+        if(this->getType() != ClientType::CLIENT_TEAMSPEAK) this->subscribeChannel({this->currentChannel}, false, true); /* su "improve" the TS3 clients join speed we send the channel clients a bit later, when the TS3 client gets his own client variables */
     }
     TIMING_STEP(timings, "join move  ");
 
@@ -761,6 +778,27 @@ void SpeakingClient::processJoin() {
     this->connectTimestamp = chrono::system_clock::now();
     this->idleTimestamp = chrono::system_clock::now();
 
+    TIMING_STEP(timings, "welcome msg");
+    {
+        std::string message{};
+        config::server::clients::WelcomeMessageType type{config::server::clients::WELCOME_MESSAGE_TYPE_NONE};
+        if(this->getType() == ClientType::CLIENT_TEASPEAK) {
+            message = config::server::clients::extra_welcome_message_teaspeak;
+            type = config::server::clients::extra_welcome_message_type_teaspeak;
+        } else if(this->getType() == ClientType::CLIENT_TEAMSPEAK) {
+            message = config::server::clients::extra_welcome_message_teamspeak;
+            type = config::server::clients::extra_welcome_message_type_teamspeak;
+        } else if(this->getType() == ClientType::CLIENT_WEB) {
+            message = config::server::clients::extra_welcome_message_teaweb;
+            type = config::server::clients::extra_welcome_message_type_teaweb;
+        }
+
+        if(type == config::server::clients::WELCOME_MESSAGE_TYPE_POKE) {
+            this->notifyClientPoke(this->server->serverRoot, message);
+        } else if(type == config::server::clients::WELCOME_MESSAGE_TYPE_CHAT) {
+            this->notifyTextMessage(ChatMessageMode::TEXTMODE_SERVER, this->server->serverRoot, 0, 0, std::chrono::system_clock::now(), message);
+        }
+    }
     debugMessage(this->getServerId(), "{} Client join timings: {}", CLIENT_STR_LOG_PREFIX, TIMING_FINISH(timings));
 }
 
@@ -837,13 +875,13 @@ command_result SpeakingClient::handleCommand(Command &command) {
         if(this->handshake.state == HandshakeState::BEGIN || this->handshake.state == HandshakeState::IDENTITY_PROOF) {
             command_result result;
             if(command.command() == "handshakebegin")
-                result = this->handleCommandHandshakeBegin(command);
+                result.reset(this->handleCommandHandshakeBegin(command));
             else if(command.command() == "handshakeindentityproof")
-                result = this->handleCommandHandshakeIdentityProof(command);
+                result.reset(this->handleCommandHandshakeIdentityProof(command));
             else
-                result = command_result{error::client_not_logged_in};
+                result.reset(command_result{error::client_not_logged_in});
 
-            if(result.error_code())
+            if(result.has_error())
                 this->postCommandHandler.push_back([&]{
                     this->close_connection(system_clock::now() + seconds(1));
                 });

server/src/client/command_handler/bulk_parsers.cpp

@@ -0,0 +1,5 @@
+//
+// Created by WolverinDEV on 07/05/2020.
+//
+
+#include "bulk_parsers.h"

server/src/client/command_handler/bulk_parsers.h

@@ -0,0 +1,242 @@
+#pragma once
+
+#include <vector>
+#include <query/Command.h>
+#include <Error.h>
+#include <PermissionManager.h>
+#include <src/client/ConnectedClient.h>
+#include "./helpers.h"
+
+namespace ts::command::bulk_parser {
+    template <bool kParseValue>
+    class PermissionBulkParser {
+        public:
+            explicit PermissionBulkParser(ts::ParameterBulk& bulk) {
+                if(bulk.has("permid")) {
+                    auto type = bulk["permid"].as<permission::PermissionType>();
+                    if ((type & PERM_ID_GRANT) != 0) {
+                        type &= ~PERM_ID_GRANT;
+                    }
+
+                    this->permission_ = permission::resolvePermissionData(type);
+                } else if(bulk.has("permsid")) {
+                    auto permission_name = bulk["permsid"].string();
+                    this->permission_ = permission::resolvePermissionData(permission_name);
+                    this->grant_ = this->permission_->grantName() == permission_name;;
+                } else {
+                    this->error_.reset(ts::command_result{error::parameter_missing, "permid"});
+                    return;
+                }
+
+                if(this->permission_->is_invalid()) {
+                    this->error_.reset(ts::command_result{error::parameter_invalid});
+                    return;
+                }
+
+                if(kParseValue) {
+                    if(!bulk.has("permvalue")) {
+                        this->error_.reset(ts::command_result{error::parameter_missing, "permvalue"});
+                        return;
+                    }
+
+                    this->value_ = bulk["permvalue"].as<permission::PermissionValue>();
+                    this->flag_skip_ = bulk.has("permskip") && bulk["permskip"].as<bool>();
+                    this->flag_negated_ = bulk.has("permnegated") && bulk["permnegated"].as<bool>();
+                }
+            }
+            PermissionBulkParser(const PermissionBulkParser&) = delete;
+            PermissionBulkParser(PermissionBulkParser&&) = default;
+
+            ~PermissionBulkParser() {
+                this->error_.release_data();
+            }
+
+            [[nodiscard]] inline bool has_error() const {
+                assert(!this->error_released_);
+                return this->error_.has_error();
+            }
+
+            [[nodiscard]] inline bool has_value() const { return this->value_ != permission::undefined; }
+            [[nodiscard]] inline bool is_grant_permission() const { return this->grant_; }
+
+            [[nodiscard]] inline const auto& permission() const { return this->permission_; }
+            [[nodiscard]] inline auto permission_type() const { return this->permission_->type; }
+
+            [[nodiscard]] inline auto value() const { return this->value_; }
+            [[nodiscard]] inline auto flag_skip() const { return this->flag_skip_; }
+            [[nodiscard]] inline auto flag_negated() const { return this->flag_negated_; }
+
+            [[nodiscard]] inline ts::command_result release_error() {
+                assert(!std::exchange(this->error_released_, true));
+                return std::move(this->error_);
+            }
+
+            inline void emplace_custom_error(ts::command_result&& result) {
+                assert(!this->error_released_);
+                this->error_.reset(std::forward<ts::command_result>(result));
+            }
+
+            inline void apply_to(const std::shared_ptr<permission::v2::PermissionManager>& manager, permission::v2::PermissionUpdateType mode) const {
+                if(this->is_grant_permission()) {
+                    manager->set_permission(this->permission_type(), { 0, this->value() }, permission::v2::PermissionUpdateType::do_nothing, mode);
+                } else {
+                    manager->set_permission(
+                            this->permission_type(),
+                            { this->value(), 0 },
+                            mode,
+                            permission::v2::PermissionUpdateType::do_nothing,
+                            this->flag_skip(),
+                            this->flag_negated()
+                    );
+                }
+            }
+
+            inline void apply_to_channel(const std::shared_ptr<permission::v2::PermissionManager>& manager, permission::v2::PermissionUpdateType mode, ChannelId channel_id) const {
+                if(this->is_grant_permission()) {
+                    manager->set_channel_permission(this->permission_type(), channel_id, { this->value(), true }, permission::v2::PermissionUpdateType::do_nothing, mode);
+                } else {
+                    manager->set_channel_permission(
+                            this->permission_type(),
+                            channel_id,
+                            { this->value(), true },
+                            mode,
+                            permission::v2::PermissionUpdateType::do_nothing
+                    );
+                }
+            }
+
+            [[nodiscard]] inline bool is_group_property() const {
+                return permission_is_group_property(this->permission_type());
+            }
+
+            [[nodiscard]] inline bool is_client_view_property() const {
+                return permission_is_client_property(this->permission_type());
+            }
+        private:
+            std::shared_ptr<permission::PermissionTypeEntry> permission_{nullptr};
+            bool grant_{false};
+
+            bool flag_skip_{false};
+            bool flag_negated_{false};
+
+            permission::PermissionValue value_{0};
+            ts::command_result error_{error::ok};
+
+#ifndef NDEBUG
+            bool error_released_{false};
+#endif
+    };
+
+    template <bool kParseValue>
+    class PermissionBulksParser {
+        public:
+            PermissionBulksParser(const PermissionBulksParser&) = delete;
+            PermissionBulksParser(PermissionBulksParser&&) = default;
+
+            template <typename base_iterator>
+            struct FilteredPermissionIterator : public base_iterator {
+                public:
+                    FilteredPermissionIterator() = default;
+                    explicit FilteredPermissionIterator(base_iterator position, base_iterator end = {}) : base_iterator{position}, end_{end} {
+                        if(*this != this->end_) {
+                            const auto& entry = **this;
+                            if(entry.has_error())
+                                this->operator++();
+                        }
+                    }
+
+                    FilteredPermissionIterator& operator++() {
+                        while(true) {
+                            base_iterator::operator++();
+                            if(*this == this->end_) break;
+
+                            const auto& entry = **this;
+                            if(!entry.has_error()) break;
+                        }
+                        return *this;
+                    }
+
+                    [[nodiscard]] FilteredPermissionIterator operator++(int) const {
+                        FilteredPermissionIterator copy = *this;
+                        ++*this;
+                        return copy;
+                    }
+
+                private:
+                    base_iterator end_;
+            };
+
+            struct FilteredPermissionListIterable {
+                typedef typename std::vector<PermissionBulkParser<kParseValue>>::const_iterator const_iterator;
+                public:
+                    FilteredPermissionListIterable(const_iterator begin, const_iterator end) noexcept : begin_{begin}, end_{end} {}
+
+                    FilteredPermissionIterator<const_iterator> begin() const {
+                        return FilteredPermissionIterator{this->begin_, this->end_};
+                    }
+
+                    FilteredPermissionIterator<const_iterator> end() const {
+                        return FilteredPermissionIterator{this->end_, this->end_};
+                    }
+                private:
+                    const_iterator begin_;
+                    const_iterator end_;
+            };
+
+            explicit PermissionBulksParser(ts::Command& command) {
+                this->permissions_.reserve(command.bulkCount());
+                for(size_t index{0}; index < command.bulkCount(); index++)
+                    this->permissions_.emplace_back(command[index]);
+            }
+
+            [[nodiscard]] inline bool validate(const std::shared_ptr<server::ConnectedClient>& issuer, ChannelId channel_id) {
+                auto ignore_granted_values = permission::v2::permission_granted(1, issuer->calculate_permission(permission::b_permission_modify_power_ignore, channel_id));
+                if(!ignore_granted_values) {
+                    auto max_value = issuer->calculate_permission(permission::i_permission_modify_power, channel_id, false);
+                    if(!max_value.has_value) {
+                        for(PermissionBulkParser<kParseValue>& permission : this->permissions_) {
+                            if(permission.has_error()) continue;
+
+                            permission.emplace_custom_error(ts::command_result{permission::i_permission_modify_power});
+                        }
+                        return false;
+                    }
+
+                    for(size_t index{0}; index < this->permissions_.size(); index++) {
+                        PermissionBulkParser<kParseValue>& permission = this->permissions_[index];
+                        if(permission.has_error()) continue;
+
+                        if(kParseValue && permission_require_granted_value(permission.permission_type()) && !permission::v2::permission_granted(permission.value(), max_value)) {
+                            permission.emplace_custom_error(ts::command_result{permission::i_permission_modify_power});
+                            continue;
+                        }
+
+                        if(!permission::v2::permission_granted(1, issuer->calculate_permission(permission.permission_type(), channel_id, true))) {
+                            permission.emplace_custom_error(ts::command_result{permission::i_permission_modify_power});
+                            continue;
+                        }
+                    }
+                }
+                return true;
+            }
+
+            [[nodiscard]] inline FilteredPermissionListIterable iterate_valid_permissions() const {
+                return FilteredPermissionListIterable{this->permissions_.begin(), this->permissions_.end()};
+            }
+
+            [[nodiscard]] inline ts::command_result build_command_result() {
+                assert(!std::exchange(this->result_created_, true));
+                ts::command_result_bulk result{};
+
+                for(auto& permission : this->permissions_)
+                    result.insert_result(std::forward<ts::command_result>(permission.release_error()));
+
+                return ts::command_result{std::move(result)};
+            }
+        private:
+            std::vector<PermissionBulkParser<kParseValue>> permissions_{};
+#ifndef NDEBUG
+            bool result_created_{false};
+#endif
+    };
+}

server/src/client/command_handler/channel.cpp

@@ -5,7 +5,7 @@
 #include "../../build.h"
 #include "../ConnectedClient.h"
 #include "../InternalClient.h"
-#include "../../server/file/FileServer.h"
+#include "src/server/file/LocalFileServer.h"
 #include "../../server/VoiceServer.h"
 #include "../voice/VoiceClient.h"
 #include "PermissionManager.h"
@@ -20,6 +20,7 @@
 #include <cstdint>
 
 #include "helpers.h"
+#include "./bulk_parsers.h"
 
 #include <Properties.h>
 #include <log/LogUtils.h>
@@ -407,46 +408,16 @@ command_result ConnectedClient::handleCommandChannelGroupAddPerm(Command &cmd) {
     if (!channelGroup || channelGroup->target() != GROUPTARGET_CHANNEL) return command_result{error::parameter_invalid, "invalid channel group id"};
     ACTION_REQUIRES_GROUP_PERMISSION(channelGroup, permission::i_channel_group_needed_modify_power, permission::i_channel_group_modify_power, true);
 
-    auto max_value = this->calculate_permission(permission::i_permission_modify_power, 0, true);
-    if(!max_value.has_value) return command_result{permission::i_permission_modify_power};
+    command::bulk_parser::PermissionBulksParser<true> pparser{cmd};
+    if(!pparser.validate(this->ref(), 0))
+        return pparser.build_command_result();
 
-    auto ignore_granted_values = permission::v2::permission_granted(1, this->calculate_permission(permission::b_permission_modify_power_ignore, 0));
-
-    auto conOnError = cmd[0].has("continueonerror");
-    bool updateList = false;
-
-    auto permission_manager = channelGroup->permissions();
-    for (int index = 0; index < cmd.bulkCount(); index++) {
-        PARSE_PERMISSION(cmd);
-
-        auto val = cmd[index]["permvalue"].as<permission::PermissionValue>();
-        if(permission_require_granted_value(permType) && !permission::v2::permission_granted(val, max_value)) {
-            if(conOnError) continue;
-            return command_result{permission::i_permission_modify_power};
-        }
-
-        if(!ignore_granted_values && !permission::v2::permission_granted(1, this->calculate_permission(permType, 0, true))) {
-            if(conOnError) continue;
-            return command_result{permission::i_permission_modify_power};
-        }
-
-        if (grant) {
-            permission_manager->set_permission(permType, {0, cmd[index]["permvalue"]}, permission::v2::PermissionUpdateType::do_nothing, permission::v2::PermissionUpdateType::set_value);
-        } else {
-            permission_manager->set_permission(
-                    permType,
-                    {cmd[index]["permvalue"], 0},
-                    permission::v2::PermissionUpdateType::set_value,
-                    permission::v2::PermissionUpdateType::do_nothing,
-
-                    cmd[index]["permskip"].as<bool>() ? 1 : 0,
-                    cmd[index]["permnegated"].as<bool>() ? 1 : 0
-            );
-            updateList |= permission_is_group_property(permType);
-        }
+    bool updateList{false};
+    for(const auto& ppermission : pparser.iterate_valid_permissions()) {
+        ppermission.apply_to(channelGroup->permissions(), permission::v2::PermissionUpdateType::set_value);
+        updateList |= ppermission.is_group_property();
     }
 
-
     if(updateList)
         channelGroup->apply_properties_from_permissions();
 
@@ -465,7 +436,8 @@ command_result ConnectedClient::handleCommandChannelGroupAddPerm(Command &cmd) {
             }
         });
     }
-    return command_result{error::ok};
+
+    return pparser.build_command_result();
 }
 
 command_result ConnectedClient::handleCommandChannelGroupDelPerm(Command &cmd) {
@@ -475,31 +447,14 @@ command_result ConnectedClient::handleCommandChannelGroupDelPerm(Command &cmd) {
     if (!channelGroup || channelGroup->target() != GROUPTARGET_CHANNEL) return command_result{error::parameter_invalid, "invalid channel group id"};
     ACTION_REQUIRES_GROUP_PERMISSION(channelGroup, permission::i_channel_group_needed_modify_power, permission::i_channel_group_modify_power, true);
 
-    auto ignore_granted_values = permission::v2::permission_granted(1, this->calculate_permission(permission::b_permission_modify_power_ignore, 0));
+    command::bulk_parser::PermissionBulksParser<false> pparser{cmd};
+    if(!pparser.validate(this->ref(), 0))
+        return pparser.build_command_result();
 
-    bool updateList = false;
-    bool conOnError = cmd[0].has("continueonerror");
-
-    auto permission_manager = channelGroup->permissions();
-    for (int index = 0; index < cmd.bulkCount(); index++) {
-        PARSE_PERMISSION(cmd)
-
-        if(!ignore_granted_values && !permission::v2::permission_granted(0, this->calculate_permission(permType, 0, true))) {
-            if(conOnError) continue;
-            return command_result{permission::i_permission_modify_power};
-        }
-
-        if (grant) {
-            permission_manager->set_permission(permType, permission::v2::empty_permission_values, permission::v2::PermissionUpdateType::do_nothing, permission::v2::PermissionUpdateType::delete_value);
-        } else {
-            permission_manager->set_permission(
-                    permType,
-                    permission::v2::empty_permission_values,
-                    permission::v2::PermissionUpdateType::delete_value,
-                    permission::v2::PermissionUpdateType::do_nothing
-            );
-            updateList |= permission_is_group_property(permType);
-        }
+    bool updateList{false};
+    for(const auto& ppermission : pparser.iterate_valid_permissions()) {
+        ppermission.apply_to(channelGroup->permissions(), permission::v2::PermissionUpdateType::delete_value);
+        updateList |= ppermission.is_group_property();
     }
 
     if(updateList)
@@ -520,7 +475,8 @@ command_result ConnectedClient::handleCommandChannelGroupDelPerm(Command &cmd) {
             }
         });
     }
-    return command_result{error::ok};
+
+    return pparser.build_command_result();
 }
 
 //TODO: Test if parent or previous is deleted!
@@ -529,51 +485,66 @@ command_result ConnectedClient::handleCommandChannelCreate(Command &cmd) {
     CMD_CHK_AND_INC_FLOOD_POINTS(25);
     CMD_CHK_PARM_COUNT(1);
 
-    //TODO: Use for this here the cache as well!
-    auto permission_cache = make_shared<CalculateCache>();
-    if (cmd[0].has("cpid") && cmd["cpid"].as<uint64_t>() != 0) ACTION_REQUIRES_GLOBAL_PERMISSION_CACHED(permission::b_channel_create_child, 1, permission_cache);
-    if (cmd[0].has("channel_order")) ACTION_REQUIRES_GLOBAL_PERMISSION_CACHED(permission::b_channel_create_with_sortorder, 1, permission_cache);
-
-    if(!cmd[0].has("channel_flag_permanent")) cmd[0]["channel_flag_permanent"] = false;
-    if(!cmd[0].has("channel_flag_semi_permanent")) cmd[0]["channel_flag_semi_permanent"] = false;
-    if(!cmd[0].has("channel_flag_default")) cmd[0]["channel_flag_default"] = false;
-    if(!cmd[0].has("channel_flag_password")) cmd[0]["channel_flag_password"] = false;
-
-    if (cmd[0]["channel_flag_permanent"].as<bool>()) ACTION_REQUIRES_GLOBAL_PERMISSION_CACHED(permission::b_channel_create_permanent, 1, permission_cache);
-    else if (cmd[0]["channel_flag_semi_permanent"].as<bool>()) ACTION_REQUIRES_GLOBAL_PERMISSION_CACHED(permission::b_channel_create_semi_permanent, 1, permission_cache);
-    else ACTION_REQUIRES_GLOBAL_PERMISSION_CACHED(permission::b_channel_create_temporary, 1, permission_cache);
-
-    if (!cmd[0]["channel_flag_permanent"].as<bool>() && !this->server) return command_result{error::parameter_invalid, "You can only create a permanent channel"};
-
-    if (cmd[0]["channel_flag_default"].as<bool>()) ACTION_REQUIRES_GLOBAL_PERMISSION_CACHED(permission::b_channel_create_with_default, 1, permission_cache);
-    if (cmd[0]["channel_flag_password"].as<bool>()) ACTION_REQUIRES_GLOBAL_PERMISSION_CACHED(permission::b_channel_create_with_password, 1, permission_cache);
-    else if(permission::v2::permission_granted(1, this->calculate_permission(permission::b_channel_create_modify_with_force_password, 0, false, permission_cache)))
-        return command_result{permission::b_channel_create_modify_with_force_password};
-
-    if(cmd[0].has("channel_password") && this->getType() == ClientType::CLIENT_QUERY)
-        cmd["channel_password"] = base64::decode(digest::sha1(cmd["channel_password"].string()));
-    if (cmd[0].has("channel_description")) ACTION_REQUIRES_GLOBAL_PERMISSION_CACHED(permission::b_channel_create_with_description, 1, permission_cache);
-    if (cmd[0].has("channel_maxclients") || (cmd[0].has("channel_flag_maxclients_unlimited") && !cmd["channel_flag_maxclients_unlimited"].as<bool>())) {
-        ACTION_REQUIRES_GLOBAL_PERMISSION_CACHED(permission::b_channel_create_with_maxclients, 1, permission_cache);
-        if(!cmd[0]["channel_flag_permanent"].as<bool>() && !cmd[0]["channel_flag_semi_permanent"].as<bool>()) {
-            cmd["channel_maxclients"] = -1;
-            cmd["channel_flag_maxclients_unlimited"] = 1;
-        }
-    }
-    if (cmd[0].has("channel_maxfamilyclients")) ACTION_REQUIRES_GLOBAL_PERMISSION_CACHED(permission::b_channel_create_with_maxfamilyclients, 1, permission_cache);
-    if (cmd[0].has("channel_needed_talk_power")) ACTION_REQUIRES_GLOBAL_PERMISSION_CACHED(permission::b_channel_create_with_needed_talk_power, 1, permission_cache);
-    if (cmd[0].has("channel_topic")) ACTION_REQUIRES_GLOBAL_PERMISSION_CACHED(permission::b_channel_create_with_topic, 1, permission_cache);
+    std::shared_ptr<TreeView::LinkedTreeEntry> parent = nullptr;
+    std::shared_ptr<BasicChannel> created_channel = nullptr, old_default_channel;
 
     auto target_tree = this->server ? this->server->channelTree : serverInstance->getChannelTree().get();
     auto& tree_lock = this->server ? this->server->channel_tree_lock : serverInstance->getChannelTreeLock();
     unique_lock tree_channel_lock(tree_lock);
 
+    if (cmd[0].has("cpid") && cmd["cpid"].as<ChannelId>() != 0 && cmd["cpid"].as<int>() != -1) {
+        parent = target_tree->findLinkedChannel(cmd["cpid"].as<ChannelId>());
+        if (!parent) return command_result{error::channel_invalid_id, "Cant resolve parent channel"};
+    }
+    ChannelId parent_channel_id = parent ? parent->entry->channelId() : 0;
+
+#define test_permission(required, permission_type) \
+    do {\
+        if(!permission::v2::permission_granted(required, this->calculate_permission(permission_type, parent_channel_id, false, permission_cache))) \
+                return command_result{permission_type};\
+    } while(0)
+
+
+    //TODO: Use for this here the cache as well!
+    auto permission_cache = make_shared<CalculateCache>();
+    if(parent) test_permission(1, permission::b_channel_create_child);
+    if (cmd[0].has("channel_order")) test_permission(1, permission::b_channel_create_with_sortorder);
+    if(!cmd[0].has("channel_flag_permanent")) cmd[0]["channel_flag_permanent"] = false;
+    if(!cmd[0].has("channel_flag_semi_permanent")) cmd[0]["channel_flag_semi_permanent"] = false;
+    if(!cmd[0].has("channel_flag_default")) cmd[0]["channel_flag_default"] = false;
+    if(!cmd[0].has("channel_flag_password")) cmd[0]["channel_flag_password"] = false;
+
+    if (cmd[0]["channel_flag_permanent"].as<bool>()) test_permission(1, permission::b_channel_create_permanent);
+    else if (cmd[0]["channel_flag_semi_permanent"].as<bool>()) test_permission(1, permission::b_channel_create_semi_permanent);
+    else test_permission(1, permission::b_channel_create_temporary);
+
+    if (!cmd[0]["channel_flag_permanent"].as<bool>() && !this->server) return command_result{error::parameter_invalid, "You can only create a permanent channel"};
+
+    if (cmd[0]["channel_flag_default"].as<bool>()) test_permission(1, permission::b_channel_create_with_default);
+    if (cmd[0]["channel_flag_password"].as<bool>()) test_permission(1, permission::b_channel_create_with_password);
+    else if(permission::v2::permission_granted(1, this->calculate_permission(permission::b_channel_create_modify_with_force_password, parent_channel_id, false, permission_cache)))
+        return command_result{permission::b_channel_create_modify_with_force_password};
+
+    if(cmd[0].has("channel_password") && this->getType() == ClientType::CLIENT_QUERY)
+        cmd["channel_password"] = base64::decode(digest::sha1(cmd["channel_password"].string()));
+    if (cmd[0].has("channel_description")) test_permission(1, permission::b_channel_create_with_description);
+    if (cmd[0].has("channel_maxclients") || (cmd[0].has("channel_flag_maxclients_unlimited") && !cmd["channel_flag_maxclients_unlimited"].as<bool>())) {
+        test_permission(1, permission::b_channel_create_with_maxclients);
+        if(!cmd[0]["channel_flag_permanent"].as<bool>() && !cmd[0]["channel_flag_semi_permanent"].as<bool>()) {
+            cmd["channel_maxclients"] = -1;
+            cmd["channel_flag_maxclients_unlimited"] = 1;
+        }
+    }
+    if (cmd[0].has("channel_maxfamilyclients")) test_permission(1, permission::b_channel_create_with_maxfamilyclients);
+    if (cmd[0].has("channel_needed_talk_power")) test_permission(1,permission::b_channel_create_with_needed_talk_power);
+    if (cmd[0].has("channel_topic")) test_permission(1,permission::b_channel_create_with_topic);
+
     if(cmd[0].has("channel_conversation_history_length")) {
         auto value = cmd["channel_conversation_history_length"].as<int64_t>();
         if(value == 0) {
-            ACTION_REQUIRES_GLOBAL_PERMISSION_CACHED(permission::b_channel_create_modify_conversation_history_unlimited, 1, permission_cache);
+            test_permission(1, permission::b_channel_create_modify_conversation_history_unlimited);
         } else {
-            ACTION_REQUIRES_GLOBAL_PERMISSION_CACHED(permission::i_channel_create_modify_conversation_history_length, 1, permission_cache);
+            test_permission(1, permission::i_channel_create_modify_conversation_history_length);
         }
     }
 
@@ -585,9 +556,10 @@ command_result ConnectedClient::handleCommandChannelCreate(Command &cmd) {
             else
                 cmd["channel_delete_delay"] = 0;
         } else {
-            ACTION_REQUIRES_GLOBAL_PERMISSION_CACHED(permission::i_channel_create_modify_with_temp_delete_delay, cmd["channel_delete_delay"].as<permission::PermissionValue>(), permission_cache);
+            test_permission(cmd["channel_delete_delay"].as<permission::PermissionValue>(), permission::i_channel_create_modify_with_temp_delete_delay);
         }
     }
+#undef test_permission
 
     {
         size_t created_total = 0, created_tmp = 0, created_semi = 0, created_perm = 0;
@@ -607,14 +579,14 @@ command_result ConnectedClient::handleCommandChannelCreate(Command &cmd) {
         if(this->server && created_total >= this->server->properties()[property::VIRTUALSERVER_MAX_CHANNELS].as<uint64_t>())
             return command_result{error::channel_limit_reached};
 
-        auto max_channels = this->calculate_permission(permission::i_client_max_channels, 0, false, permission_cache);
+        auto max_channels = this->calculate_permission(permission::i_client_max_channels, parent_channel_id, false, permission_cache);
         if(max_channels.has_value) {
             if(!permission::v2::permission_granted(created_perm + created_semi + created_tmp + 1, max_channels))
                 return command_result{permission::i_client_max_channels};
         }
 
         if (cmd[0]["channel_flag_permanent"].as<bool>()) {
-            max_channels = this->calculate_permission(permission::i_client_max_permanent_channels, 0, false, permission_cache);
+            max_channels = this->calculate_permission(permission::i_client_max_permanent_channels, parent_channel_id, false, permission_cache);
 
             if(max_channels.has_value) {
                 if(!permission::v2::permission_granted(created_perm + 1, max_channels))
@@ -622,7 +594,7 @@ command_result ConnectedClient::handleCommandChannelCreate(Command &cmd) {
             }
         }
         else if (cmd[0]["channel_flag_semi_permanent"].as<bool>()) {
-            max_channels = this->calculate_permission(permission::i_client_max_semi_channels, 0, false, permission_cache);
+            max_channels = this->calculate_permission(permission::i_client_max_semi_channels, parent_channel_id, false, permission_cache);
 
             if(max_channels.has_value) {
                 if(!permission::v2::permission_granted(created_semi + 1, max_channels))
@@ -630,7 +602,7 @@ command_result ConnectedClient::handleCommandChannelCreate(Command &cmd) {
             }
         }
         else {
-            max_channels = this->calculate_permission(permission::i_client_max_temporary_channels, 0, false, permission_cache);
+            max_channels = this->calculate_permission(permission::i_client_max_temporary_channels, parent_channel_id, false, permission_cache);
 
             if(max_channels.has_value) {
                 if(!permission::v2::permission_granted(created_tmp + 1, max_channels))
@@ -640,20 +612,12 @@ command_result ConnectedClient::handleCommandChannelCreate(Command &cmd) {
     }
 
     //TODO check voice (opus etc)
-    std::shared_ptr<TreeView::LinkedTreeEntry> parent = nullptr;
-    std::shared_ptr<BasicChannel> created_channel = nullptr, old_default_channel;
-
     //bool enforce_permanent_parent = cmd[0]["channel_flag_default"].as<bool>(); //TODO check parents here
     { //Checkout the parent(s)
-        if (cmd[0].has("cpid") && cmd["cpid"].as<ChannelId>() != 0 && cmd["cpid"].as<int>() != -1) {
-            parent = target_tree->findLinkedChannel(cmd["cpid"].as<ChannelId>());
-            if (!parent) return command_result{error::channel_invalid_id, "Cant resolve parent channel"};
-        }
-
         {
 
-            auto min_channel_deep = this->calculate_permission(permission::i_channel_min_depth, 0, false, permission_cache);
-            auto max_channel_deep = this->calculate_permission(permission::i_channel_max_depth, 0, false, permission_cache);
+            auto min_channel_deep = this->calculate_permission(permission::i_channel_min_depth, parent_channel_id, false, permission_cache);
+            auto max_channel_deep = this->calculate_permission(permission::i_channel_max_depth, parent_channel_id, false, permission_cache);
 
             if(min_channel_deep.has_value || max_channel_deep.has_value) {
                 auto channel_deep = 0;
@@ -704,8 +668,8 @@ command_result ConnectedClient::handleCommandChannelCreate(Command &cmd) {
     created_channel->properties()[property::CHANNEL_CREATED_BY] = this->getClientDatabaseId();
 
     {
-        auto default_modify_power = this->calculate_permission(permission::i_channel_modify_power, 0, false, permission_cache);
-        auto default_delete_power = this->calculate_permission(permission::i_channel_delete_power, 0, false, permission_cache);
+        auto default_modify_power = this->calculate_permission(permission::i_channel_modify_power, parent_channel_id, false, permission_cache);
+        auto default_delete_power = this->calculate_permission(permission::i_channel_delete_power, parent_channel_id, false, permission_cache);
 
         auto permission_manager = created_channel->permissions();
         permission_manager->set_permission(
@@ -729,14 +693,14 @@ command_result ConnectedClient::handleCommandChannelCreate(Command &cmd) {
         if (prop == "cpid") continue;
         if (prop == "cid") continue;
 
-        const auto &property = property::info<property::ChannelProperties>(prop);
-        if(*property == property::CHANNEL_UNDEFINED) {
+        const auto &property = property::find<property::ChannelProperties>(prop);
+        if(property == property::CHANNEL_UNDEFINED) {
             logError(this->getServerId(), "Client " + this->getDisplayName() + " tried to change a not existing channel property " + prop);
             continue;
         }
 
-        if(!property->validate_input(cmd[prop].as<string>())) {
-            logError(this->getServerId(), "Client " + this->getDisplayName() + " tried to change a property to an invalid value. (Value: '" + cmd[prop].as<string>() + "', Property: '" + property->name + "')");
+        if(!property.validate_input(cmd[prop].as<string>())) {
+            logError(this->getServerId(), "Client " + this->getDisplayName() + " tried to change a property to an invalid value. (Value: '" + cmd[prop].as<string>() + "', Property: '" + std::string{property.name} + "')");
             continue;
         }
         created_channel->properties()[property] = cmd[prop].as<std::string>();
@@ -839,7 +803,7 @@ command_result ConnectedClient::handleCommandChannelEdit(Command &cmd) {
         return command_result{error::ok};
     }
 
-    std::deque<std::shared_ptr<property::PropertyDescription>> keys;
+    std::deque<const property::PropertyDescription*> keys;
     bool require_write_lock = false;
     bool update_max_clients = false;
     bool update_max_family_clients = false;
@@ -858,23 +822,23 @@ command_result ConnectedClient::handleCommandChannelEdit(Command &cmd) {
         if(key == "return_code")
             continue;
 
-        const auto &property = property::info<property::ChannelProperties>(key);
-        if(*property == property::CHANNEL_UNDEFINED) {
+        const auto &property = property::find<property::ChannelProperties>(key);
+        if(property == property::CHANNEL_UNDEFINED) {
             logError(this->getServerId(), R"({} Tried to edit a not existing channel property "{}" to "{}")", CLIENT_STR_LOG_PREFIX, key, cmd[key].string());
             continue;
         }
 
-        if((property->flags & property::FLAG_USER_EDITABLE) == 0) {
+        if((property.flags & property::FLAG_USER_EDITABLE) == 0) {
             logError(this->getServerId(), "{} Tried to change a channel property which is not changeable. (Key: {}, Value: \"{}\")", CLIENT_STR_LOG_PREFIX, key, cmd[key].string());
             continue;
         }
 
-        if(!property->validate_input(cmd[key].as<string>())) {
+        if(!property.validate_input(cmd[key].as<string>())) {
             logError(this->getServerId(), "{} Tried to change a channel property to an invalid value. (Key: {}, Value: \"{}\")", CLIENT_STR_LOG_PREFIX, key, cmd[key].string());
             continue;
         }
 
-        if(channel->properties()[*property].as<string>()  == cmd[key].as<string>())
+        if(channel->properties()[property].as<string>()  == cmd[key].as<string>())
             continue; /* we dont need to update stuff which is the same */
 
         if(key == "channel_icon_id") {
@@ -964,7 +928,7 @@ command_result ConnectedClient::handleCommandChannelEdit(Command &cmd) {
             );
             continue;
         }
-        keys.push_back(property);
+        keys.push_back(&property);
     }
 
     unique_lock server_channel_w_lock(this->server ? this->server->channel_tree_lock : serverInstance->getChannelTreeLock(), defer_lock);
@@ -984,11 +948,11 @@ command_result ConnectedClient::handleCommandChannelEdit(Command &cmd) {
                 return command_result{error::parameter_missing};
             else
                 cmd["channel_password"] = ""; /* no password set */
-            keys.push_back(property::info<property::ChannelProperties>(property::CHANNEL_PASSWORD));
+            keys.push_back(&property::describe(property::CHANNEL_PASSWORD));
         }
         if(!cmd[0].has("channel_flag_password")) {
             cmd["channel_flag_password"] = !cmd["channel_password"].string().empty();
-            keys.push_back(property::info<property::ChannelProperties>(property::CHANNEL_FLAG_PASSWORD));
+            keys.push_back(&property::describe(property::CHANNEL_FLAG_PASSWORD));
         }
 
         if(cmd["channel_flag_password"].as<bool>()) {
@@ -1004,27 +968,28 @@ command_result ConnectedClient::handleCommandChannelEdit(Command &cmd) {
     }
 
     /* test the default channel update */
-    if(cmd[0].has("channel_flag_default") || channel->defaultChannel()) {
+    const auto target_will_be_default = cmd[0].has("channel_flag_default") ? cmd["channel_flag_default"].as<bool>() : channel->defaultChannel();
+    if(target_will_be_default) {
         if(target_channel_type != ChannelType::permanent)
             return command_result{error::channel_default_require_permanent}; /* default channel is not allowed to be non permanent */
 
         if((cmd[0].has("channel_flag_password") && cmd["channel_flag_password"].as<bool>()) || channel->properties()[property::CHANNEL_FLAG_PASSWORD]) {
             cmd["channel_flag_password"] = false;
             cmd["channel_password"] = "";
-            keys.push_back(property::info<property::ChannelProperties>(property::CHANNEL_FLAG_PASSWORD));
+            keys.push_back(&property::describe(property::CHANNEL_FLAG_PASSWORD));
         }
 
-        if(cmd[0].has("channel_flag_default")) {
+        if(target_will_be_default) {
             cmd["channel_maxclients"] = -1;
             cmd["channel_flag_maxclients_unlimited"] = true;
-            keys.push_back(property::info<property::ChannelProperties>(property::CHANNEL_MAXCLIENTS));
-            keys.push_back(property::info<property::ChannelProperties>(property::CHANNEL_FLAG_MAXCLIENTS_UNLIMITED));
+            keys.push_back(&property::describe(property::CHANNEL_MAXCLIENTS));
+            keys.push_back(&property::describe(property::CHANNEL_FLAG_MAXCLIENTS_UNLIMITED));
             update_max_clients = true;
 
             cmd["channel_maxfamilyclients"] = -1;
-            cmd["channel_flag_maxfamilyclients_inherited"] = true;
-            keys.push_back(property::info<property::ChannelProperties>(property::CHANNEL_MAXFAMILYCLIENTS));
-            keys.push_back(property::info<property::ChannelProperties>(property::CHANNEL_FLAG_MAXFAMILYCLIENTS_INHERITED));
+            cmd["channel_flag_maxfamilyclients_inherited"] = false;
+            keys.push_back(&property::describe(property::CHANNEL_MAXFAMILYCLIENTS));
+            keys.push_back(&property::describe(property::CHANNEL_FLAG_MAXFAMILYCLIENTS_INHERITED));
             update_max_family_clients = true;
         }
     }
@@ -1035,15 +1000,15 @@ command_result ConnectedClient::handleCommandChannelEdit(Command &cmd) {
             if(channel->properties()[property::CHANNEL_MAXCLIENTS].as<int>() != -1) {
                 cmd["channel_maxclients"] = -1;
                 cmd["channel_flag_maxclients_unlimited"] = true;
-                keys.push_back(property::info<property::ChannelProperties>(property::CHANNEL_MAXCLIENTS));
-                keys.push_back(property::info<property::ChannelProperties>(property::CHANNEL_FLAG_MAXCLIENTS_UNLIMITED));
+                keys.push_back(&property::describe(property::CHANNEL_MAXCLIENTS));
+                keys.push_back(&property::describe(property::CHANNEL_FLAG_MAXCLIENTS_UNLIMITED));
                 update_max_clients = true;
             }
             if(channel->properties()[property::CHANNEL_MAXFAMILYCLIENTS].as<int>() != -1) {
                 cmd["channel_maxfamilyclients"] = -1;
                 cmd["channel_flag_maxfamilyclients_inherited"] = true;
-                keys.push_back(property::info<property::ChannelProperties>(property::CHANNEL_MAXFAMILYCLIENTS));
-                keys.push_back(property::info<property::ChannelProperties>(property::CHANNEL_FLAG_MAXFAMILYCLIENTS_INHERITED));
+                keys.push_back(&property::describe(property::CHANNEL_MAXFAMILYCLIENTS));
+                keys.push_back(&property::describe(property::CHANNEL_FLAG_MAXFAMILYCLIENTS_INHERITED));
                 update_max_family_clients = true;
             }
         }
@@ -1066,12 +1031,12 @@ command_result ConnectedClient::handleCommandChannelEdit(Command &cmd) {
                 cmd["channel_maxclients"] = -1;
             else
                 return command_result{error::parameter_missing, "channel_maxclients"}; /* max clients must be specified */
-            keys.push_back(property::info<property::ChannelProperties>(property::CHANNEL_MAXCLIENTS));
+            keys.push_back(&property::describe(property::CHANNEL_MAXCLIENTS));
         }
 
         if(!cmd[0].has("channel_flag_maxclients_unlimited")) {
             cmd["channel_flag_maxclients_unlimited"] = cmd["channel_maxclients"].as<int>() < 0;
-            keys.push_back(property::info<property::ChannelProperties>(property::CHANNEL_FLAG_MAXCLIENTS_UNLIMITED));
+            keys.push_back(&property::describe(property::CHANNEL_FLAG_MAXCLIENTS_UNLIMITED));
         }
 
         if(cmd["channel_flag_maxclients_unlimited"].as<bool>() && cmd["channel_maxclients"].as<int>() != -1)
@@ -1083,32 +1048,24 @@ command_result ConnectedClient::handleCommandChannelEdit(Command &cmd) {
 
     /* test the max family clients parameters */
     if(update_max_family_clients) {
+        //auto channel_maxfamilyclients = cmd[0].has("channel_maxfamilyclients") ? std::optional<int>{cmd["channel_maxfamilyclients"].as<int>()} : std::nullopt;
+        //auto channel_flag_maxfamilyclients_unlimited = cmd[0].has("channel_flag_maxfamilyclients_unlimited") ? std::optional<bool>{cmd["channel_flag_maxfamilyclients_unlimited"].as<bool>()} : std::nullopt;
+        //auto channel_flag_maxfamilyclients_inherited = cmd[0].has("channel_flag_maxfamilyclients_inherited") ? std::optional<bool>{cmd["channel_flag_maxfamilyclients_inherited"].as<bool>()} : std::nullopt;
+
+        /* update actual count from flags */
         if(!cmd[0].has("channel_maxfamilyclients")) {
-            if(cmd[0].has("channel_flag_maxfamilyclients_unlimited")) {
-                if(cmd["channel_flag_maxfamilyclients_unlimited"].as<bool>())
-                    cmd["channel_flag_maxfamilyclients_inherited"] = false;
-                else
-                    cmd["channel_flag_maxfamilyclients_inherited"] = true;
-                keys.push_back(property::info<property::ChannelProperties>(property::CHANNEL_FLAG_MAXFAMILYCLIENTS_INHERITED));
-            } else if(cmd[0].has("channel_flag_maxfamilyclients_inherited")) {
-                if(cmd["channel_flag_maxfamilyclients_inherited"].as<bool>())
-                    cmd["channel_flag_maxfamilyclients_unlimited"] = false;
-                else
-                    cmd["channel_flag_maxfamilyclients_unlimited"] = true;
-                keys.push_back(property::info<property::ChannelProperties>(property::CHANNEL_FLAG_MAXFAMILYCLIENTS_UNLIMITED));
-            } else /* not really possible */
-                return command_result{error::parameter_missing, "channel_maxfamilyclients"}; /* family max clients must be  */
-            cmd["channel_maxfamilyclients"] = -1;
-            keys.push_back(property::info<property::ChannelProperties>(property::CHANNEL_MAXFAMILYCLIENTS));
-        }
-        //keep this order because this command: "channeledit cid=<x> channel_maxfamilyclients=-1" should set max family clients mode to inherited
-        if(!cmd[0].has("channel_flag_maxfamilyclients_inherited")) {
-            auto flag_unlimited = cmd[0].has("channel_flag_maxfamilyclients_unlimited") && cmd["channel_flag_maxfamilyclients_unlimited"].as<bool>();
-            if(flag_unlimited)
-                cmd["channel_flag_maxfamilyclients_inherited"] = false;
-            else
-                cmd["channel_flag_maxfamilyclients_inherited"] = cmd["channel_maxfamilyclients"].as<int>() < 0;
+            if(cmd[0].has("channel_flag_maxfamilyclients_unlimited") && cmd["channel_flag_maxfamilyclients_unlimited"].as<bool>()) {
+                cmd["channel_maxfamilyclients"] = -1;
+                keys.push_back(&property::describe(property::CHANNEL_MAXFAMILYCLIENTS));
+            } else if(cmd[0].has("channel_flag_maxfamilyclients_inherited") && cmd["channel_flag_maxfamilyclients_inherited"].as<bool>()) {
+                cmd["channel_maxfamilyclients"] = -1;
+                keys.push_back(&property::describe(property::CHANNEL_MAXFAMILYCLIENTS));
+            } else {
+                return command_result{error::parameter_missing, "channel_maxfamilyclients"}; /* since its not unlimited or inherited, channel_maxfamilyclients must be specified */
+            }
         }
+
+        //Update the flags from channel_maxfamilyclients if needed
         if(!cmd[0].has("channel_flag_maxfamilyclients_unlimited")) {
             auto flag_inherited = cmd[0].has("channel_flag_maxfamilyclients_inherited") && cmd["channel_flag_maxfamilyclients_inherited"].as<bool>();
             if(flag_inherited)
@@ -1117,6 +1074,15 @@ command_result ConnectedClient::handleCommandChannelEdit(Command &cmd) {
                 cmd["channel_flag_maxfamilyclients_unlimited"] = cmd["channel_maxfamilyclients"].as<int>() < 0;
         }
 
+        if(!cmd[0].has("channel_flag_maxfamilyclients_inherited")) {
+            auto flag_unlimited = cmd[0].has("channel_flag_maxfamilyclients_unlimited") && cmd["channel_flag_maxfamilyclients_unlimited"].as<bool>();
+            if(flag_unlimited)
+                cmd["channel_flag_maxfamilyclients_inherited"] = false;
+            else
+                cmd["channel_flag_maxfamilyclients_inherited"] = cmd["channel_maxfamilyclients"].as<int>() < 0;
+        }
+
+        /* final checkup */
         if(cmd["channel_flag_maxfamilyclients_inherited"].as<bool>() && cmd["channel_flag_maxfamilyclients_unlimited"].as<bool>())
             return command_result{error::channel_invalid_flags}; /* both at the same time are not possible */
 
@@ -1140,10 +1106,10 @@ command_result ConnectedClient::handleCommandChannelEdit(Command &cmd) {
     auto self_ref = this->ref();
     shared_ptr<BasicChannel> old_default_channel;
     deque<shared_ptr<BasicChannel>> child_channel_updated;
-    for(const std::shared_ptr<property::PropertyDescription>& key : keys) {
+    for(const property::PropertyDescription* key : keys) {
         if(*key == property::CHANNEL_ORDER) {
             /* TODO: May move that up because if it fails may some other props have already be applied */
-            if (!channel_tree->change_order(channel, cmd[key->name]))
+            if (!channel_tree->change_order(channel, cmd[std::string{key->name}]))
                 return command_result{error::channel_invalid_order, "Can't change order id"};
 
             if(this->server) {
@@ -1186,7 +1152,7 @@ command_result ConnectedClient::handleCommandChannelEdit(Command &cmd) {
                 continue;
             }
 
-            if(!cmd[key->name].as<bool>()) {
+            if(!cmd[std::string{key->name}].as<bool>()) {
                 old_default_channel = nullptr;
                 continue;
             }
@@ -1245,13 +1211,13 @@ command_result ConnectedClient::handleCommandChannelEdit(Command &cmd) {
             if(conversation_manager) {
                 auto conversation = conversation_manager->get(channel->channelId());
                 if(conversation)
-                    conversation->set_history_length(cmd[key->name]);
+                    conversation->set_history_length(cmd[std::string{key->name}]);
             }
         } else if(*key == property::CHANNEL_NEEDED_TALK_POWER) {
             channel->permissions()->set_permission(permission::i_client_needed_talk_power, {cmd[key->name].as<int>(), 0}, permission::v2::set_value, permission::v2::do_nothing);
         }
 
-        channel->properties()[key] = cmd[key->name].string();
+        channel->properties()[*key] = cmd[std::string{key->name}].string();
     }
     if(this->server) {
         vector<property::ChannelProperties> key_vector;
@@ -1471,101 +1437,33 @@ command_result ConnectedClient::handleCommandChannelAddPerm(Command &cmd) {
 
     ACTION_REQUIRES_CHANNEL_PERMISSION(channel, permission::i_channel_needed_permission_modify_power, permission::i_channel_permission_modify_power, true);
 
-    auto max_value = this->calculate_permission(permission::i_permission_modify_power, channel_id, true);
-    if(!max_value.has_value) return command_result{permission::i_permission_modify_power};
-
-    auto ignore_granted_values = permission::v2::permission_granted(1, this->calculate_permission(permission::b_permission_modify_power_ignore, channel_id));
-    auto updateClients = false, update_view = false, update_channel_properties = false;
-
-    bool conOnError = cmd[0].has("continueonerror");
+    command::bulk_parser::PermissionBulksParser<true> pparser{cmd};
+    if(!pparser.validate(this->ref(), channel->channelId()))
+        return pparser.build_command_result();
 
     auto permission_manager = channel->permissions();
-    for (int index = 0; index < cmd.bulkCount(); index++) {
-        PARSE_PERMISSION(cmd);
+    auto updateClients = false, update_join_permissions = false, update_channel_properties = false;
+    for(const auto& ppermission : pparser.iterate_valid_permissions()) {
+        ppermission.apply_to(permission_manager, permission::v2::PermissionUpdateType::set_value);
 
-        auto val = cmd[index]["permvalue"].as<permission::PermissionValue>();
-        if(permission_require_granted_value(permType) && !permission::v2::permission_granted(val, max_value)) {
-            if(conOnError) continue;
-            return command_result{permission::i_permission_modify_power};
-        }
-
-        if(!ignore_granted_values && !permission::v2::permission_granted(1, this->calculate_permission(permType, channel_id, true))) {
-            if(conOnError) continue;
-            return command_result{permission::i_permission_modify_power};
-        }
-
-
-        if (grant) {
-            permission_manager->set_permission(permType, {0, cmd[index]["permvalue"]}, permission::v2::PermissionUpdateType::do_nothing, permission::v2::PermissionUpdateType::set_value);
-        } else {
-            permission_manager->set_permission(
-                    permType,
-                    {cmd[index]["permvalue"], 0},
-                    permission::v2::PermissionUpdateType::set_value,
-                    permission::v2::PermissionUpdateType::do_nothing,
-
-                    cmd[index]["permskip"].as<bool>() ? 1 : 0,
-                    cmd[index]["permnegated"].as<bool>() ? 1 : 0
-            );
-            updateClients |= permission_is_client_property(permType);
-            update_view |= permType == permission::i_channel_needed_view_power;
-            update_channel_properties |= channel->permission_require_property_update(permType);
-
-            if (permType == permission::i_icon_id) {
-                if(this->server) {
-                    auto self_ref = this->ref();
-                    this->server->forEachClient([&](std::shared_ptr<ConnectedClient> cl) {
-                        shared_lock client_channel_lock(cl->channel_lock);
-                        cl->notifyChannelEdited(channel, {property::CHANNEL_ICON_ID}, self_ref, false);
-                    });
-                }
-                continue;
-            }
-        }
+        updateClients |= ppermission.is_client_view_property();
+        update_join_permissions = ppermission.permission_type() == permission::i_channel_needed_join_power;
+        update_channel_properties |= channel->permission_require_property_update(ppermission.permission_type());
     }
 
-    /* broadcast the updated channel properties */
-    if(update_channel_properties) {
-        auto updates = channel->update_properties_from_permissions();
-        if(!updates.empty() && this->server){
-            auto self_ref = this->ref();
-            this->server->forEachClient([&](std::shared_ptr<ConnectedClient> cl) {
-                shared_lock client_channel_lock(cl->channel_lock);
-                cl->notifyChannelEdited(channel, updates, self_ref, false);
-            });
-        }
-    }
+    if(update_channel_properties && this->server)
+        this->server->update_channel_from_permissions(channel, this->ref());
 
-    if(updateClients && this->server)
-        for(const auto& client : this->server->getClientsByChannel(channel)) {
-            /* let them lock the server channel tree as well (read lock so does not matter) */
-            client->updateChannelClientProperties(true, true);
-            client->join_state_id++; /* join permission may changed, all channels need to be recalculate dif needed */
-        }
-
-    if(update_view && this->server) {
-        auto l_source = this->server->channelTree->findLinkedChannel(channel->channelId());
-        this->server->forEachClient([&](const shared_ptr<ConnectedClient>& cl) {
-            /* server tree read lock still active */
-            auto l_target = !cl->currentChannel ? nullptr : cl->server->channelTree->findLinkedChannel(cl->currentChannel->channelId());
-            sassert(l_source);
-            if(cl->currentChannel) sassert(l_target);
-
-            {
-                unique_lock client_channel_lock(cl->channel_lock);
-
-                deque<ChannelId> deleted;
-                for(const auto& update_entry : cl->channels->update_channel(l_source, l_target)) {
-                    if(update_entry.first)
-                        cl->notifyChannelShow(update_entry.second->channel(), update_entry.second->previous_channel);
-                    else deleted.push_back(update_entry.second->channelId());
-                }
-                if(!deleted.empty())
-                    cl->notifyChannelHide(deleted, false);
-            }
+    if((updateClients || update_join_permissions) && this->server) {
+        this->server->forEachClient([&](std::shared_ptr<ConnectedClient> cl) {
+            if(updateClients && cl->currentChannel == channel)
+                cl->updateChannelClientProperties(true, true);
+            if(update_join_permissions)
+                cl->join_state_id++;
         });
     }
-    return command_result{error::ok};;
+
+    return pparser.build_command_result();
 }
 
 command_result ConnectedClient::handleCommandChannelDelPerm(Command &cmd) {
@@ -1577,71 +1475,33 @@ command_result ConnectedClient::handleCommandChannelDelPerm(Command &cmd) {
 
     ACTION_REQUIRES_CHANNEL_PERMISSION(channel, permission::i_channel_needed_permission_modify_power, permission::i_channel_permission_modify_power, true);
 
-    auto ignore_granted_values = permission::v2::permission_granted(1, this->calculate_permission(permission::b_permission_modify_power_ignore, channel_id));
-    bool conOnError = cmd[0].has("continueonerror");
-    auto updateClients = false, update_view = false, update_channel_properties = false;
+    command::bulk_parser::PermissionBulksParser<false> pparser{cmd};
+    if(!pparser.validate(this->ref(), channel->channelId()))
+        return pparser.build_command_result();
 
     auto permission_manager = channel->permissions();
-    for (int index = 0; index < cmd.bulkCount(); index++) {
-        PARSE_PERMISSION(cmd);
+    auto updateClients = false, update_join_permissions = false, update_channel_properties = false;
+    for(const auto& ppermission : pparser.iterate_valid_permissions()) {
+        ppermission.apply_to(permission_manager, permission::v2::PermissionUpdateType::delete_value);
 
-        if(!ignore_granted_values && !permission::v2::permission_granted(0, this->calculate_permission(permType, channel_id, true))) {
-            if(conOnError) continue;
-            return command_result{permission::i_permission_modify_power};
-        }
-
-        if (grant) {
-            permission_manager->set_permission(permType, permission::v2::empty_permission_values, permission::v2::PermissionUpdateType::do_nothing, permission::v2::PermissionUpdateType::delete_value);
-        } else {
-            permission_manager->set_permission(permType, permission::v2::empty_permission_values, permission::v2::PermissionUpdateType::delete_value, permission::v2::PermissionUpdateType::do_nothing);
-            updateClients |= permission_is_client_property(permType);
-            update_view |= permType == permission::i_channel_needed_view_power;
-            update_channel_properties |= channel->permission_require_property_update(permType);
-        }
+        updateClients |= ppermission.is_client_view_property();
+        update_join_permissions = ppermission.permission_type() == permission::i_channel_needed_join_power;
+        update_channel_properties |= channel->permission_require_property_update(ppermission.permission_type());
     }
 
-    /* broadcast the updated channel properties */
-    if(update_channel_properties) {
-        auto updates = channel->update_properties_from_permissions();
-        if(!updates.empty() && this->server){
-            auto self_ref = this->ref();
-            this->server->forEachClient([&](std::shared_ptr<ConnectedClient> cl) {
-                shared_lock client_channel_lock(cl->channel_lock);
-                cl->notifyChannelEdited(channel, updates, self_ref, false);
-            });
-        }
-    }
+    if(update_channel_properties && this->server)
+        this->server->update_channel_from_permissions(channel, this->ref());
 
-    if(updateClients && this->server)
+    if((updateClients || update_join_permissions) && this->server) {
         this->server->forEachClient([&](std::shared_ptr<ConnectedClient> cl) {
-            if(cl->currentChannel == channel) {
+            if(updateClients && cl->currentChannel == channel)
                 cl->updateChannelClientProperties(true, true);
-                cl->join_state_id++; /* join permission may changed, all channels need to be recalculate dif needed */
-            }
-        });
-    if(update_view && this->server) {
-        this->server->forEachClient([&](std::shared_ptr<ConnectedClient> cl) {
-            /* server tree read lock still active */
-            auto l_source = cl->server->channelTree->findLinkedChannel(channel->channelId());
-            auto l_target = !cl->currentChannel ? nullptr : cl->server->channelTree->findLinkedChannel(cl->currentChannel->channelId());
-            sassert(l_source);
-            if(cl->currentChannel) sassert(l_target);
-
-            {
-                unique_lock client_channel_lock(cl->channel_lock);
-
-                deque<ChannelId> deleted;
-                for(const auto& update_entry : cl->channels->update_channel(l_source, l_target)) {
-                    if(update_entry.first)
-                        cl->notifyChannelShow(update_entry.second->channel(), update_entry.second->previous_channel);
-                    else deleted.push_back(update_entry.second->channelId());
-                }
-                if(!deleted.empty())
-                    cl->notifyChannelHide(deleted, false);
-            }
+            if(update_join_permissions)
+                cl->join_state_id++;
         });
     }
-    return command_result{error::ok};
+
+    return pparser.build_command_result();
 }
 
 command_result ConnectedClient::handleCommandChannelClientPermList(Command &cmd) {
@@ -1720,29 +1580,21 @@ command_result ConnectedClient::handleCommandChannelClientDelPerm(Command &cmd)
         ACTION_REQUIRES_PERMISSION(permission::i_client_permission_modify_power, required_permissions, channel_id);
     }
 
-    auto ignore_granted_values = permission::v2::permission_granted(1, this->calculate_permission(permission::b_permission_modify_power_ignore, channel_id));
+    command::bulk_parser::PermissionBulksParser<false> pparser{cmd};
+    if(!pparser.validate(this->ref(), channel->channelId()))
+        return pparser.build_command_result();
 
-    bool conOnError = cmd[0].has("continueonerror"), update_view = false;
-    auto cll = this->server->findClientsByCldbId(cldbid);
-    for (int index = 0; index < cmd.bulkCount(); index++) {
-        PARSE_PERMISSION(cmd);
-
-        if(!ignore_granted_values && !permission::v2::permission_granted(0, this->calculate_permission(permType, channel_id, true))) {
-            if(conOnError) continue;
-            return command_result{permission::i_permission_modify_power};
-        }
-
-        if (grant) {
-            mgr->set_channel_permission(permType, channel->channelId(), permission::v2::empty_permission_values, permission::v2::do_nothing, permission::v2::delete_value);
-        } else {
-            mgr->set_channel_permission(permType, channel->channelId(), permission::v2::empty_permission_values, permission::v2::delete_value, permission::v2::do_nothing);
-            update_view = permType == permission::b_channel_ignore_view_power || permType == permission::i_channel_view_power;
-        }
+    bool update_view{false};
+    for(const auto& ppermission : pparser.iterate_valid_permissions()) {
+        ppermission.apply_to_channel(mgr, permission::v2::PermissionUpdateType::delete_value, channel->channelId());
+        update_view |= ppermission.is_client_view_property();
     }
 
     serverInstance->databaseHelper()->saveClientPermissions(this->server, cldbid, mgr);
-    if (!cll.empty()) {
-        for (const auto &elm : cll) {
+
+    auto onlineClients = this->server->findClientsByCldbId(cldbid);
+    if (!onlineClients.empty()) {
+        for (const auto &elm : onlineClients) {
             if(elm->update_cached_permissions()) /* update cached calculated permissions */
                 elm->sendNeededPermissions(false); /* cached permissions had changed, notify the client */
 
@@ -1768,7 +1620,7 @@ command_result ConnectedClient::handleCommandChannelClientDelPerm(Command &cmd)
         }
     }
 
-    return command_result{error::ok};
+    return pparser.build_command_result();
 }
 
 command_result ConnectedClient::handleCommandChannelClientAddPerm(Command &cmd) {
@@ -1785,45 +1637,25 @@ command_result ConnectedClient::handleCommandChannelClientAddPerm(Command &cmd)
     if(!channel) return command_result{error::vs_critical};
 
     auto mgr = serverInstance->databaseHelper()->loadClientPermissionManager(this->server, cldbid);
-    {
-        auto required_permissions = this->server->calculate_permission(permission::i_client_needed_permission_modify_power, cmd["cldbid"], ClientType::CLIENT_TEAMSPEAK, channel_id);
-        ACTION_REQUIRES_PERMISSION(permission::i_client_permission_modify_power, required_permissions, channel_id);
-    }
+    auto required_permissions = this->server->calculate_permission(permission::i_client_needed_permission_modify_power, cmd["cldbid"], ClientType::CLIENT_TEAMSPEAK, channel_id);
+    ACTION_REQUIRES_PERMISSION(permission::i_client_permission_modify_power, required_permissions, channel_id);
 
-    auto max_value = this->calculate_permission(permission::i_permission_modify_power, channel_id, true);
-    if(!max_value.has_value) return command_result{permission::i_permission_modify_power};
+    command::bulk_parser::PermissionBulksParser<true> pparser{cmd};
+    if(!pparser.validate(this->ref(), channel->channelId()))
+        return pparser.build_command_result();
 
-    auto ignore_granted_values = permission::v2::permission_granted(1, this->calculate_permission(permission::b_permission_modify_power_ignore, channel_id));
-    auto update_view = false;
-
-    bool conOnError = cmd[0].has("continueonerror");
-    auto onlineClientInstances = this->server->findClientsByCldbId(cldbid);
-
-    for (int index = 0; index < cmd.bulkCount(); index++) {
-        PARSE_PERMISSION(cmd);
-
-        auto val = cmd[index]["permvalue"].as<permission::PermissionValue>();
-        if(permission_require_granted_value(permType) && !permission::v2::permission_granted(val, max_value)) {
-            if(conOnError) continue;
-            return command_result{permission::i_permission_modify_power};
-        }
-
-        if(!ignore_granted_values && !permission::v2::permission_granted(1, this->calculate_permission(permType, channel_id, true))) {
-            if(conOnError) continue;
-            return command_result{permission::i_permission_modify_power};
-        }
-
-        if (grant) {
-            mgr->set_channel_permission(permType, channel->channelId(), {0, cmd[index]["permvalue"]}, permission::v2::do_nothing, permission::v2::set_value);
-        } else {
-            mgr->set_channel_permission(permType, channel->channelId(), {cmd[index]["permvalue"], 0}, permission::v2::set_value, permission::v2::do_nothing,  cmd[index]["permskip"] ? 1 : 0, cmd[index]["permnegated"] ? 1 : 0);
-            update_view = permType == permission::b_channel_ignore_view_power || permType == permission::i_channel_view_power;
-        }
+    bool update_view{false};
+    for(const auto& ppermission : pparser.iterate_valid_permissions()) {
+        ppermission.apply_to_channel(mgr, permission::v2::PermissionUpdateType::set_value, channel->channelId());
+        update_view |= ppermission.is_client_view_property();
     }
 
     serverInstance->databaseHelper()->saveClientPermissions(this->server, cldbid, mgr);
-    if (!onlineClientInstances.empty())
-        for (const auto &elm : onlineClientInstances) {
+
+
+    auto onlineClients = this->server->findClientsByCldbId(cldbid);
+    if (!onlineClients.empty())
+        for (const auto &elm : onlineClients) {
             if (elm->update_cached_permissions()) /* update cached calculated permissions */
                 elm->sendNeededPermissions(false); /* cached permissions had changed, notify the client */
 
@@ -1847,7 +1679,7 @@ command_result ConnectedClient::handleCommandChannelClientAddPerm(Command &cmd)
             elm->join_state_id++; /* join permission may changed, all channels need to be recalculate dif needed */
         }
 
-    return command_result{error::ok};
+    return pparser.build_command_result();
 }
 
 

server/src/client/command_handler/client.cpp

@@ -1,11 +1,12 @@
 #include <memory>
 
+#include <vector>
 #include <bitset>
 #include <algorithm>
 #include "../../build.h"
 #include "../ConnectedClient.h"
 #include "../InternalClient.h"
-#include "../../server/file/FileServer.h"
+#include "src/server/file/LocalFileServer.h"
 #include "../voice/VoiceClient.h"
 #include "PermissionManager.h"
 #include "../../InstanceHandler.h"
@@ -19,6 +20,7 @@
 #include <cstdint>
 
 #include "helpers.h"
+#include "./bulk_parsers.h"
 
 #include <Properties.h>
 #include <log/LogUtils.h>
@@ -39,17 +41,21 @@ using namespace ts::token;
 command_result ConnectedClient::handleCommandClientGetVariables(Command &cmd) {
     CMD_REQ_SERVER;
     ConnectedLockedClient client{this->server->find_client_by_id(cmd["clid"].as<ClientId>())};
-    shared_lock tree_lock(this->channel_lock);
+    {
+        shared_lock tree_lock(this->channel_lock);
 
-    if (!client || (client.client != this && !this->isClientVisible(client.client, false)))
-        return command_result{error::client_invalid_id, ""};
+        if (!client || (client.client != this && !this->isClientVisible(client.client, false)))
+            return command_result{error::client_invalid_id, ""};
 
-    deque<shared_ptr<property::PropertyDescription>> props;
-    for (auto &prop : client->properties()->list_properties(property::FLAG_CLIENT_VARIABLE, this->getType() == CLIENT_TEAMSPEAK ? property::FLAG_NEW : (uint16_t) 0)) {
-        props.push_back(property::info((property::ClientProperties) prop.type().property_index));
+        deque<const property::PropertyDescription*> props;
+        for (auto &prop : client->properties()->list_properties(property::FLAG_CLIENT_VARIABLE, this->getType() == CLIENT_TEAMSPEAK ? property::FLAG_NEW : (uint16_t) 0)) {
+            props.push_back(&prop.type());
+        }
+
+        this->notifyClientUpdated(client.client, props, false);
     }
-
-    this->notifyClientUpdated(client.client, props, false);
+    if(client.client == this && this->getType() == ClientType::CLIENT_TEAMSPEAK)
+        this->subscribeChannel({this->currentChannel}, true, true); /* lets show the clients in the current channel because we've not done that while joining (speed improvement ;))*/
     return command_result{error::ok};
 }
 
@@ -57,29 +63,56 @@ command_result ConnectedClient::handleCommandClientKick(Command &cmd) {
     CMD_REQ_SERVER;
     CMD_CHK_AND_INC_FLOOD_POINTS(25);
 
-    ConnectedLockedClient client{this->server->find_client_by_id(cmd["clid"].as<ClientId>())};
-    if (!client) return command_result{error::client_invalid_id};
-    if (client->getType() == CLIENT_MUSIC) return command_result{error::client_invalid_type, "You cant kick a music bot!"};
-    std::shared_ptr<BasicChannel> targetChannel = nullptr;
-    auto type = cmd["reasonid"].as<ViewReasonId>();
-    if (type == ViewReasonId::VREASON_CHANNEL_KICK) {
-        auto channel = client->getChannel();
-        ACTION_REQUIRES_PERMISSION(permission::i_client_kick_from_channel_power, client->calculate_permission(permission::i_client_needed_kick_from_channel_power, client->getChannelId()), client->getChannelId());
-        targetChannel = this->server->channelTree->getDefaultChannel();
-    } else if (type == ViewReasonId::VREASON_SERVER_KICK) {
-        auto channel = client->getChannel();
-        ACTION_REQUIRES_GLOBAL_PERMISSION(permission::i_client_kick_from_server_power, client->calculate_permission(permission::i_client_needed_kick_from_server_power, client->getChannelId()));
-        targetChannel = nullptr;
-    } else return command_result{error::not_implemented};
+    command_result_bulk result{};
+    result.reserve(cmd.bulkCount());
 
-    if (targetChannel) {
-        this->server->notify_client_kick(client.client, this->ref(), cmd["reasonmsg"].as<std::string>(), targetChannel);
-    } else {
-        this->server->notify_client_kick(client.client, this->ref(), cmd["reasonmsg"].as<std::string>(), nullptr);
-        client->close_connection(system_clock::now() + seconds(1));
+    std::vector<ConnectedLockedClient<ConnectedClient>> clients{};
+    clients.reserve(cmd.bulkCount());
+
+    auto type = cmd["reasonid"].as<ViewReasonId>();
+    auto target_channel = type == ViewReasonId::VREASON_CHANNEL_KICK ? this->server->channelTree->getDefaultChannel() : nullptr;
+    auto kick_power = type == ViewReasonId::VREASON_CHANNEL_KICK ?
+            this->calculate_permission(permission::i_client_kick_from_channel_power, target_channel->channelId()) :
+            this->calculate_permission(permission::i_client_kick_from_server_power, 0);
+
+    for(size_t index = 0; index < cmd.bulkCount(); index++) {
+        ConnectedLockedClient<ConnectedClient> client{this->server->find_client_by_id(cmd[index]["clid"].as<ClientId>())};
+
+        if (!client) {
+            result.emplace_result(error::client_invalid_id);
+            continue;
+        }
+        if (client->getType() == CLIENT_MUSIC) {
+            result.emplace_result(error::client_invalid_type);
+            continue;
+        }
+
+        if(type == ViewReasonId::VREASON_CHANNEL_KICK) {
+            if(!permission::v2::permission_granted(client->calculate_permission(permission::i_client_needed_kick_from_channel_power, client->getChannelId()), kick_power)) {
+                result.emplace_result(permission::i_client_needed_kick_from_channel_power);
+                continue;
+            }
+        } else {
+            if(!permission::v2::permission_granted(client->calculate_permission(permission::i_client_needed_kick_from_server_power, client->getChannelId()), kick_power)) {
+                result.emplace_result(permission::i_client_needed_kick_from_server_power);
+                continue;
+            }
+        }
+
+        clients.emplace_back(std::move(client));
+        result.emplace_result(error::ok);
     }
 
-    return command_result{error::ok};
+    for(auto& client : clients) {
+        if (target_channel) {
+            this->server->notify_client_kick(client.client, this->ref(), cmd["reasonmsg"].as<std::string>(), target_channel);
+        } else {
+            this->server->notify_client_kick(client.client, this->ref(), cmd["reasonmsg"].as<std::string>(), nullptr);
+            client->close_connection(system_clock::now() + seconds(1));
+        }
+    }
+
+    return command_result{std::forward<command_result_bulk>(result)};
 }
 
 command_result ConnectedClient::handleCommandClientGetIds(Command &cmd) {
@@ -126,16 +159,7 @@ command_result ConnectedClient::handleCommandClientMove(Command &cmd) {
     CMD_CHK_AND_INC_FLOOD_POINTS(10);
 
     shared_lock server_channel_r_lock(this->server->channel_tree_lock);
-    auto target_client_id = cmd["clid"].as<ClientId>();
-    ConnectedLockedClient target_client{target_client_id == 0 ? this->ref() : this->server->find_client_by_id(target_client_id)};
-    if(!target_client) {
-        return command_result{error::client_invalid_id, "Invalid target clid"};
-    }
 
-    if(!target_client->getChannel()) {
-        if(target_client.client != this)
-            return command_result{error::client_invalid_id, "Invalid target clid"};
-    }
     auto channel = this->server->channelTree->findChannel(cmd["cid"].as<ChannelId>());
     if (!channel) {
         return command_result{error::channel_invalid_id};
@@ -144,6 +168,7 @@ command_result ConnectedClient::handleCommandClientMove(Command &cmd) {
     auto permission_cache = make_shared<CalculateCache>();
     if(!cmd[0].has("cpw"))
         cmd["cpw"] = "";
+
     if (!channel->passwordMatch(cmd["cpw"], true))
         if (!permission::v2::permission_granted(1, this->calculate_permission(permission::b_channel_join_ignore_password, channel->channelId())))
             return command_result{error::channel_invalid_password};
@@ -151,11 +176,49 @@ command_result ConnectedClient::handleCommandClientMove(Command &cmd) {
     auto permission_error = this->calculate_and_get_join_state(channel);
     if(permission_error != permission::unknown) return command_result{permission_error};
 
+    command_result_bulk result{};
+    result.reserve(cmd.bulkCount());
+
+    std::vector<ConnectedLockedClient<ConnectedClient>> clients{};
+
+    for(size_t index{0}; index < cmd.bulkCount(); index++) {
+        auto target_client_id = cmd[index]["clid"].as<ClientId>();
+        ConnectedLockedClient target_client{target_client_id == 0 ? this->ref() : this->server->find_client_by_id(target_client_id)};
+        if(!target_client) {
+            result.emplace_result(error::client_invalid_id);
+            continue;
+        }
+
+        if(!target_client->getChannel()) {
+            if(target_client.client != this) {
+                result.emplace_result(error::client_invalid_id);
+                continue;
+            }
+        }
+        if(target_client->getChannel() == channel) {
+            result.emplace_result(error::ok);
+            continue;
+        }
+
+        if(target_client.client != this) {
+            if(!permission::v2::permission_granted(target_client->calculate_permission(permission::i_client_needed_move_power, target_client->getChannelId()), this->calculate_permission(permission::i_client_move_power, target_client->getChannelId()))) {
+                result.emplace_result(permission::i_client_move_power);
+                continue;
+            }
+            if(!permission::v2::permission_granted(target_client->calculate_permission(permission::i_client_needed_move_power, channel->channelId()), this->calculate_permission(permission::i_client_move_power, channel->channelId()))) {
+                result.emplace_result(permission::i_client_move_power);
+                continue;
+            }
+        }
+        clients.emplace_back(std::move(target_client));
+        result.emplace_result(error::ok);
+    }
+
     if (!channel->properties()[property::CHANNEL_FLAG_MAXCLIENTS_UNLIMITED].as<bool>() || !channel->properties()[property::CHANNEL_FLAG_MAXFAMILYCLIENTS_UNLIMITED].as<bool>()) {
         if(!permission::v2::permission_granted(1, this->calculate_permission(permission::b_channel_join_ignore_maxclients, channel->channelId()))) {
             if(!channel->properties()[property::CHANNEL_FLAG_MAXCLIENTS_UNLIMITED].as<bool>()) {
                 auto maxClients = channel->properties()[property::CHANNEL_MAXCLIENTS].as<int32_t>();
-                if (maxClients >= 0 && maxClients <= this->server->getClientsByChannel(channel).size())
+                if (maxClients >= 0 && maxClients < this->server->getClientsByChannel(channel).size() + clients.size())
                     return command_result{error::channel_maxclients_reached};
             }
             if(!channel->properties()[property::CHANNEL_FLAG_MAXFAMILYCLIENTS_UNLIMITED].as<bool>()) {
@@ -163,36 +226,45 @@ command_result ConnectedClient::handleCommandClientMove(Command &cmd) {
 
                 if(channel->properties()[property::CHANNEL_FLAG_MAXFAMILYCLIENTS_INHERITED].as<bool>()) {
                     family_root = channel;
-                    while(family_root && family_root->properties()[property::CHANNEL_FLAG_MAXFAMILYCLIENTS_INHERITED].as<bool>()) family_root = family_root->parent();
+                    while(family_root && family_root->properties()[property::CHANNEL_FLAG_MAXFAMILYCLIENTS_INHERITED].as<bool>())
+                        family_root = family_root->parent();
                 }
                 if(family_root && !family_root->properties()[property::CHANNEL_FLAG_MAXFAMILYCLIENTS_UNLIMITED]) { //Could not be CHANNEL_FLAG_MAXFAMILYCLIENTS_INHERITED
                     auto maxClients = family_root->properties()[property::CHANNEL_MAXFAMILYCLIENTS].as<int32_t>();
-                    auto clients = 0;
-                    for(const auto& entry : this->server->getClientsByChannelRoot(channel, false)) if(entry.get() != this) clients++; //Dont count the client itself
-                    if (maxClients >= 0 && maxClients <= clients)
+                    auto client_count = 0;
+                    for(const auto& entry : this->server->getClientsByChannelRoot(channel, false))
+                        if(entry.get() != this) client_count++; //Dont count the client itself
+
+                    if (maxClients >= 0 && maxClients < client_count + clients.size())
                         return command_result{error::channel_maxfamily_reached};
                 }
             }
         }
     }
 
-    if (target_client.client != this)
-        ACTION_REQUIRES_PERMISSION(permission::i_client_move_power, target_client->calculate_permission(permission::i_client_needed_move_power, target_client->getChannelId()), target_client->getChannelId());
-
     server_channel_r_lock.unlock();
     unique_lock server_channel_w_lock(this->server->channel_tree_lock);
-    auto oldChannel = target_client->getChannel();
-    this->server->client_move(
-            target_client.client,
-            channel,
-            target_client.client == this ? nullptr : _this.lock(),
-            "",
-            target_client.client == this ? ViewReasonId::VREASON_USER_ACTION : ViewReasonId::VREASON_MOVED,
-            true,
-            server_channel_w_lock
-    );
+    std::vector<std::shared_ptr<BasicChannel>> channels{};
+    channels.reserve(clients.size());
 
-    if(oldChannel) {
+    for(auto& client : clients) {
+        auto oldChannel = client->getChannel();
+        if(!oldChannel) continue;
+
+        this->server->client_move(
+                client.client,
+                channel,
+                client.client == this ? nullptr : _this.lock(),
+                "",
+                client.client == this ? ViewReasonId::VREASON_USER_ACTION : ViewReasonId::VREASON_MOVED,
+                true,
+                server_channel_w_lock
+        );
+        if(std::find_if(channels.begin(), channels.end(), [&](const std::shared_ptr<BasicChannel>& channel) { return &*channel == &*oldChannel; }) == channels.end())
+            channels.push_back(oldChannel);
+    }
+
+    for(const auto& oldChannel : channels) {
         if(!server_channel_w_lock.owns_lock())
             server_channel_w_lock.lock();
         if(oldChannel->channelType() == ChannelType::temporary && oldChannel->properties()[property::CHANNEL_DELETE_DELAY].as<int64_t>() == 0)
@@ -201,7 +273,7 @@ command_result ConnectedClient::handleCommandClientMove(Command &cmd) {
         if(server_channel_w_lock.owns_lock())
             server_channel_w_lock.unlock();
     }
-    return command_result{error::ok};
+    return command_result{std::forward<command_result_bulk>(result)};
 }
 
 command_result ConnectedClient::handleCommandClientPoke(Command &cmd) {
@@ -209,13 +281,45 @@ command_result ConnectedClient::handleCommandClientPoke(Command &cmd) {
     CMD_RESET_IDLE;
     CMD_CHK_AND_INC_FLOOD_POINTS(25);
 
-    ConnectedLockedClient client{ this->server->find_client_by_id(cmd["clid"].as<ClientId>())};
-    if (!client) return command_result{error::client_invalid_id};
-    if (client->getType() == CLIENT_MUSIC) return command_result{error::client_invalid_type};
-    ACTION_REQUIRES_PERMISSION(permission::i_client_poke_power, client->calculate_permission(permission::i_client_needed_poke_power, client->getChannelId()), client->getChannelId());
+    command_result_bulk result{};
+    result.reserve(cmd.bulkCount());
 
-    client->notifyClientPoke(_this.lock(), cmd["msg"]);
-    return command_result{error::ok};
+    std::vector<ConnectedLockedClient<ConnectedClient>> clients{};
+    clients.reserve(cmd.bulkCount());
+
+    for(size_t index{0}; index < cmd.bulkCount(); index++) {
+        ConnectedLockedClient client{ this->server->find_client_by_id(cmd[index]["clid"].as<ClientId>())};
+        if (!client) {
+            result.emplace_result(error::client_invalid_id);
+            continue;
+        }
+        if (client->getType() == CLIENT_MUSIC) {
+            result.emplace_result(error::client_invalid_type);
+            continue;
+        }
+
+        auto own_permission = this->calculate_permission(permission::i_client_poke_power, client->getChannelId());
+        if(!permission::v2::permission_granted(client->calculate_permission(permission::i_client_needed_poke_power, client->getChannelId()), own_permission)) {
+            result.emplace_result(permission::i_client_poke_power);
+            continue;
+        }
+
+        clients.push_back(std::move(client));
+        result.emplace_result(error::ok);
+    }
+
+    /* clients might be empty ;) */
+
+    if(clients.size() > 1) {
+        auto max_clients = this->calculate_permission(permission::i_client_poke_max_clients, 0);
+        if(!permission::v2::permission_granted(clients.size(), max_clients))
+            return command_result{permission::i_client_poke_max_clients};
+    }
+
+    for(auto& client : clients)
+        client->notifyClientPoke(_this.lock(), cmd["msg"]);
+
+    return command_result{std::forward<command_result_bulk>(result)};
 }
 
 
@@ -391,13 +495,13 @@ command_result ConnectedClient::handleCommandClientDBEdit(Command &cmd) {
     for (auto &elm : cmd[0].keys()) {
         if (elm == "cldbid") continue;
 
-        auto info = property::info<property::ClientProperties>(elm);
-        if(*info == property::CLIENT_UNDEFINED) {
+        const auto& info = property::find<property::ClientProperties>(elm);
+        if(info == property::CLIENT_UNDEFINED) {
             logError(this->getServerId(), "Client " + this->getDisplayName() + " tried to change someone's db entry, but the entry in unknown: " + elm);
             continue;
         }
-        if(!info->validate_input(cmd[elm].as<string>())) {
-            logError(this->getServerId(), "Client " + this->getDisplayName() + " tried to change a property to an invalid value. (Value: '" + cmd[elm].as<string>() + "', Property: '" + info->name + "')");
+        if(!info.validate_input(cmd[elm].as<string>())) {
+            logError(this->getServerId(), "Client " + this->getDisplayName() + " tried to change a property to an invalid value. (Value: '" + cmd[elm].as<string>() + "', Property: '" + std::string{info.name} + "')");
             continue;
         }
         (*props)[info] = cmd[elm].string();
@@ -423,29 +527,29 @@ command_result ConnectedClient::handleCommandClientEdit(Command &cmd, const std:
 
     bool update_talk_rights = false;
     unique_ptr<lock_guard<std::recursive_mutex>> nickname_lock;
-    deque<pair<property::ClientProperties, string>> keys;
+    std::deque<std::pair<const property::PropertyDescription*, std::string>> keys;
     for(const auto& key : cmd[0].keys()) {
         if(key == "return_code") continue;
         if(key == "clid") continue;
 
-        const auto &info = property::info<property::ClientProperties>(key);
-        if(*info == property::CLIENT_UNDEFINED) {
+        const auto &info = property::find<property::ClientProperties>(key);
+        if(info == property::CLIENT_UNDEFINED) {
             logError(this->getServerId(), R"([{}] Tried to change a not existing client property for {}. (Key: "{}", Value: "{}"))", CLIENT_STR_LOG_PREFIX, CLIENT_STR_LOG_PREFIX_(client), key, cmd[key].string());
             continue;
         }
 
-        if((info->flags & property::FLAG_USER_EDITABLE) == 0) {
+        if((info.flags & property::FLAG_USER_EDITABLE) == 0) {
             logError(this->getServerId(), R"([{}] Tried to change a not user editable client property for {}. (Key: "{}", Value: "{}"))", CLIENT_STR_LOG_PREFIX, CLIENT_STR_LOG_PREFIX_(client), key, cmd[key].string());
             continue;
         }
 
-        if(!info->validate_input(cmd[key].as<string>())) {
+        if(!info.validate_input(cmd[key].as<string>())) {
             logError(this->getServerId(), R"([{}] Tried to change a client property to an invalid value for {}. (Key: "{}", Value: "{}"))", CLIENT_STR_LOG_PREFIX, CLIENT_STR_LOG_PREFIX_(client), key, cmd[key].string());
             continue;
         }
-        if(client->properties()[info].as<string>() == cmd[key].as<string>()) continue;
+        if(client->properties()[&info].as<string>() == cmd[key].as<string>()) continue;
 
-        if (*info == property::CLIENT_DESCRIPTION) {
+        if (info == property::CLIENT_DESCRIPTION) {
             if (self) {
                 ACTION_REQUIRES_PERMISSION(permission::b_client_modify_own_description, 1, client->getChannelId());
             } else if(client->getType() == ClientType::CLIENT_MUSIC) {
@@ -458,16 +562,16 @@ command_result ConnectedClient::handleCommandClientEdit(Command &cmd, const std:
 
             string value = cmd["client_description"].string();
             if (count_characters(value) > 200) return command_result{error::parameter_invalid, "Invalid description length. A maximum of 200 characters is allowed!"};
-        } else if (*info == property::CLIENT_IS_TALKER) {
+        } else if (info == property::CLIENT_IS_TALKER) {
             ACTION_REQUIRES_PERMISSION(permission::b_client_set_flag_talker, 1, client->getChannelId());
             cmd["client_is_talker"] = cmd["client_is_talker"].as<bool>();
             cmd["client_talk_request"] = 0;
             update_talk_rights = true;
 
-            keys.emplace_back(property::CLIENT_IS_TALKER, "client_is_talker");
-            keys.emplace_back(property::CLIENT_TALK_REQUEST, "client_talk_request");
+            keys.emplace_back(&property::describe(property::CLIENT_IS_TALKER), "client_is_talker");
+            keys.emplace_back(&property::describe(property::CLIENT_TALK_REQUEST), "client_talk_request");
             continue;
-        } else if(*info == property::CLIENT_NICKNAME) {
+        } else if(info == property::CLIENT_NICKNAME) {
             if(!self) {
                 if(client->getType() != ClientType::CLIENT_MUSIC) return command_result{error::client_invalid_type};
                 if(client->properties()[property::CLIENT_OWNER] != this->getClientDatabaseId()) {
@@ -500,7 +604,7 @@ command_result ConnectedClient::handleCommandClientEdit(Command &cmd, const std:
                     continue;
                 }
             }
-        } else if(*info == property::CLIENT_PLAYER_VOLUME) {
+        } else if(info == property::CLIENT_PLAYER_VOLUME) {
             if(client->getType() != ClientType::CLIENT_MUSIC) return command_result{error::client_invalid_type};
             if(client->properties()[property::CLIENT_OWNER] != this->getClientDatabaseId()) {
                 ACTION_REQUIRES_PERMISSION(permission::i_client_music_modify_power, client->calculate_permission(permission::i_client_music_needed_modify_power, client->getChannelId()), client->getChannelId());
@@ -515,7 +619,7 @@ command_result ConnectedClient::handleCommandClientEdit(Command &cmd, const std:
                 return command_result{permission::i_client_music_create_modify_max_volume};
 
             bot->volume_modifier(cmd["player_volume"]);
-        } else if(*info == property::CLIENT_IS_CHANNEL_COMMANDER) {
+        } else if(info == property::CLIENT_IS_CHANNEL_COMMANDER) {
             if(!self) {
                 if(client->getType() != ClientType::CLIENT_MUSIC) return command_result{error::client_invalid_type};
                 if(client->properties()[property::CLIENT_OWNER] != this->getClientDatabaseId()) {
@@ -525,7 +629,7 @@ command_result ConnectedClient::handleCommandClientEdit(Command &cmd, const std:
 
             if(cmd["client_is_channel_commander"].as<bool>())
                 ACTION_REQUIRES_PERMISSION(permission::b_client_use_channel_commander, 1, client->getChannelId());
-        } else if(*info == property::CLIENT_IS_PRIORITY_SPEAKER) {
+        } else if(info == property::CLIENT_IS_PRIORITY_SPEAKER) {
             //FIXME allow other to remove this thing
             if(!self) {
                 if(client->getType() != ClientType::CLIENT_MUSIC)
@@ -544,7 +648,7 @@ command_result ConnectedClient::handleCommandClientEdit(Command &cmd, const std:
                 cmd["client_talk_request"] = duration_cast<seconds>(system_clock::now().time_since_epoch()).count();
             else
                 cmd["client_talk_request"] = 0;
-            keys.emplace_back(property::CLIENT_TALK_REQUEST, "client_talk_request");
+            keys.emplace_back(&property::describe(property::CLIENT_TALK_REQUEST), "client_talk_request");
             continue;
         } else if (self && key == "client_badges") {
             std::string str = cmd[key];
@@ -576,7 +680,7 @@ command_result ConnectedClient::handleCommandClientEdit(Command &cmd, const std:
             if(client->properties()[property::CLIENT_OWNER] != this->getClientDatabaseId()) {
                 ACTION_REQUIRES_PERMISSION(permission::i_client_music_modify_power, client->calculate_permission(permission::i_client_music_needed_modify_power, client->getChannelId()), client->getChannelId());
             }
-        } else if(!self && (*info == property::CLIENT_FLAG_NOTIFY_SONG_CHANGE/* || *info == property::CLIENT_NOTIFY_SONG_MESSAGE*/)) {
+        } else if(!self && (info == property::CLIENT_FLAG_NOTIFY_SONG_CHANGE/* || info == property::CLIENT_NOTIFY_SONG_MESSAGE*/)) {
             if(client->getType() != ClientType::CLIENT_MUSIC) return command_result{error::client_invalid_type};
             if(client->properties()[property::CLIENT_OWNER] != this->getClientDatabaseId()) {
                 ACTION_REQUIRES_PERMISSION(permission::i_client_music_modify_power, client->calculate_permission(permission::i_client_music_needed_modify_power, client->getChannelId()), client->getChannelId());
@@ -596,8 +700,8 @@ command_result ConnectedClient::handleCommandClientEdit(Command &cmd, const std:
                 cmd["client_lastconnected"] = value;
             }
 
-            keys.emplace_back(property::CLIENT_LASTCONNECTED, "client_lastconnected");
-        } else if(!self && *info == property::CLIENT_BOT_TYPE) {
+            keys.emplace_back(&property::describe(property::CLIENT_LASTCONNECTED), "client_lastconnected");
+        } else if(!self && info == property::CLIENT_BOT_TYPE) {
             ACTION_REQUIRES_PERMISSION(permission::i_client_music_modify_power, client->calculate_permission(permission::i_client_music_needed_modify_power, client->getChannelId()), client->getChannelId());
             auto type = cmd["client_bot_type"].as<MusicClient::Type::value>();
             if(type == MusicClient::Type::TEMPORARY) {
@@ -608,7 +712,7 @@ command_result ConnectedClient::handleCommandClientEdit(Command &cmd, const std:
                 ACTION_REQUIRES_PERMISSION(permission::b_client_music_modify_permanent, 1, client->getChannelId());
             } else
                 return command_result{error::parameter_invalid};
-        } else if(*info == property::CLIENT_AWAY_MESSAGE) {
+        } else if(info == property::CLIENT_AWAY_MESSAGE) {
             if(!self) continue;
 
             if(cmd["client_away_message"].string().length() > 256)
@@ -617,12 +721,12 @@ command_result ConnectedClient::handleCommandClientEdit(Command &cmd, const std:
             continue;
         }
 
-        keys.emplace_back((property::ClientProperties) info->property_index, key);
+        keys.emplace_back(&info, key);
     }
 
-    deque<property::ClientProperties> updates;
+    deque<const property::PropertyDescription*> updates;
     for(const auto& key : keys) {
-        if(key.first == property::CLIENT_IS_PRIORITY_SPEAKER) {
+        if(*key.first == property::CLIENT_IS_PRIORITY_SPEAKER) {
             client->clientPermissions->set_permission(permission::b_client_is_priority_speaker, {1, 0}, cmd["client_is_priority_speaker"].as<bool>() ? permission::v2::PermissionUpdateType::set_value : permission::v2::PermissionUpdateType::delete_value, permission::v2::PermissionUpdateType::do_nothing);
         }
         client->properties()[key.first] = cmd[0][key.second].value();
@@ -870,33 +974,17 @@ command_result ConnectedClient::handleCommandClientAddPerm(Command &cmd) {
     auto mgr = serverInstance->databaseHelper()->loadClientPermissionManager(this->server, cldbid);
 
     ACTION_REQUIRES_GLOBAL_PERMISSION(permission::i_client_permission_modify_power, this->server->calculate_permission(permission::i_client_needed_permission_modify_power, cldbid, ClientType::CLIENT_TEAMSPEAK, 0));
-    auto max_value = this->calculate_permission(permission::i_permission_modify_power, 0, true);
-    if(!max_value.has_value) return command_result{permission::i_permission_modify_power};
 
-    auto ignore_granted_values = permission::v2::permission_granted(1, this->calculate_permission(permission::b_permission_modify_power_ignore, 0));
-    bool conOnError = cmd[0].has("continueonerror");
-    auto update_channels = false;
-    for (int index = 0; index < cmd.bulkCount(); index++) {
-        PARSE_PERMISSION(cmd);
+    command::bulk_parser::PermissionBulksParser<true> pparser{cmd};
+    if(!pparser.validate(this->ref(), 0))
+        return pparser.build_command_result();
 
-        auto val = cmd[index]["permvalue"].as<permission::PermissionValue>();
-        if(permission_require_granted_value(permType) && !permission::v2::permission_granted(val, max_value)) {
-            if(conOnError) continue;
-            return command_result{permission::i_permission_modify_power};
-        }
-
-        if(!ignore_granted_values && !permission::v2::permission_granted(1, this->calculate_permission(permType, 0, true))) {
-            if(conOnError) continue;
-            return command_result{permission::i_permission_modify_power};
-        }
-
-        if (grant) {
-            mgr->set_permission(permType, {0, cmd[index]["permvalue"]}, permission::v2::do_nothing, permission::v2::set_value);
-        } else {
-            mgr->set_permission(permType, {cmd[index]["permvalue"], 0}, permission::v2::set_value, permission::v2::do_nothing,  cmd[index]["permskip"] ? 1 : 0, cmd[index]["permnegated"] ? 1 : 0);
-            update_channels |= permission_is_client_property(permType);
-        }
+    bool update_channels{false};
+    for(const auto& ppermission : pparser.iterate_valid_permissions()) {
+        ppermission.apply_to(mgr, permission::v2::PermissionUpdateType::set_value);
+        update_channels |= ppermission.is_client_view_property();
     }
+
     serverInstance->databaseHelper()->saveClientPermissions(this->server, cldbid, mgr);
     auto onlineClients = this->server->findClientsByCldbId(cldbid);
     if (!onlineClients.empty())
@@ -908,7 +996,7 @@ command_result ConnectedClient::handleCommandClientAddPerm(Command &cmd) {
             elm->join_state_id++; /* join permission may changed, all channels need to be recalculate dif needed */
         }
 
-    return command_result{error::ok};
+    return pparser.build_command_result();
 }
 
 command_result ConnectedClient::handleCommandClientDelPerm(Command &cmd) {
@@ -922,37 +1010,28 @@ command_result ConnectedClient::handleCommandClientDelPerm(Command &cmd) {
     auto mgr = serverInstance->databaseHelper()->loadClientPermissionManager(this->server, cldbid);
     ACTION_REQUIRES_GLOBAL_PERMISSION(permission::i_client_permission_modify_power, this->server->calculate_permission(permission::i_client_needed_permission_modify_power, cldbid, ClientType::CLIENT_TEAMSPEAK, 0));
 
-    auto ignore_granted_values = permission::v2::permission_granted(1, this->calculate_permission(permission::b_permission_modify_power_ignore, 0));
-    bool conOnError = cmd[0].has("continueonerror");
-    auto onlineClients = this->server->findClientsByCldbId(cmd["cldbid"]);
-    auto update_channel = false;
-    for (int index = 0; index < cmd.bulkCount(); index++) {
-        PARSE_PERMISSION(cmd)
+    command::bulk_parser::PermissionBulksParser<false> pparser{cmd};
+    if(!pparser.validate(this->ref(), 0))
+        return pparser.build_command_result();
 
-        if(!ignore_granted_values && !permission::v2::permission_granted(0, this->calculate_permission(permType, 0, true))) {
-            if(conOnError) continue;
-            return command_result{permission::i_permission_modify_power};
-        }
-
-
-        if (grant) {
-            mgr->set_permission(permType, permission::v2::empty_permission_values, permission::v2::do_nothing, permission::v2::delete_value);
-        } else {
-            mgr->set_permission(permType, permission::v2::empty_permission_values, permission::v2::delete_value, permission::v2::do_nothing);
-            update_channel |= permission_is_client_property(permType);
-        }
+    bool update_channels{false};
+    for(const auto& ppermission : pparser.iterate_valid_permissions()) {
+        ppermission.apply_to(mgr, permission::v2::PermissionUpdateType::delete_value);
+        update_channels |= ppermission.is_client_view_property();
     }
 
     serverInstance->databaseHelper()->saveClientPermissions(this->server, cldbid, mgr);
+    auto onlineClients = this->server->findClientsByCldbId(cldbid);
     if (!onlineClients.empty())
         for (const auto &elm : onlineClients) {
             if(elm->update_cached_permissions()) /* update cached calculated permissions */
                 elm->sendNeededPermissions(false); /* cached permissions had changed, notify the client */
-            if(update_channel)
+            if(update_channels)
                 elm->updateChannelClientProperties(true, true);
             elm->join_state_id++; /* join permission may changed, all channels need to be recalculate dif needed */
         }
-    return command_result{error::ok};
+
+    return pparser.build_command_result();
 }
 
 command_result ConnectedClient::handleCommandClientPermList(Command &cmd) {
@@ -1116,7 +1195,7 @@ command_result ConnectedClient::handleCommandClientInfo(Command &cmd) {
         }
 
         for (const auto &key : client->properties()->list_properties(property::FLAG_CLIENT_VIEW | property::FLAG_CLIENT_VARIABLE | property::FLAG_CLIENT_INFO, this->getType() == CLIENT_TEAMSPEAK ? property::FLAG_NEW : (uint16_t) 0))
-            res[result_index][key.type().name] = key.value();
+            res[result_index][std::string{key.type().name}] = key.value();
         if(view_remote)
             res[result_index]["connection_client_ip"] = client->properties()[property::CONNECTION_CLIENT_IP].as<string>();
         else

server/src/client/command_handler/file.cpp

@@ -13,7 +13,7 @@
 #include "../../build.h"
 #include "../ConnectedClient.h"
 #include "../InternalClient.h"
-#include "../../server/file/FileServer.h"
+#include "src/server/file/LocalFileServer.h"
 #include "../../server/VoiceServer.h"
 #include "../voice/VoiceClient.h"
 #include "PermissionManager.h"
@@ -118,14 +118,9 @@ command_result ConnectedClient::handleCommandFTGetFileList(Command &cmd) {
     }
 
     if (fileList[0].has("name")) {
-        if(dynamic_cast<VoiceClient*>(this)) {
-            dynamic_cast<VoiceClient*>(this)->sendCommand0(fileList.build(), false, true); /* We need to process this directly else the order could get shuffled up! */
+        this->sendCommand(fileList);
+        if(this->getType() != CLIENT_QUERY)
             this->sendCommand(fileListFinished);
-        } else {
-            this->sendCommand(fileList);
-            if(this->getType() != CLIENT_QUERY)
-                this->sendCommand(fileListFinished);
-        }
         return command_result{error::ok};
     } else {
         return command_result{error::database_empty_result};
@@ -234,13 +229,11 @@ command_result ConnectedClient::handleCommandFTInitUpload(Command &cmd) {
             directory = serverInstance->getFileServer()->avatarDirectory(this->server);
             cmd["name"] = "/avatar_" + this->getAvatarId();
         } else {
-            cerr << "Unknown requested directory: " << cmd["path"].as<std::string>() << endl;
             return command_result{error::not_implemented};
         }
     }
 
     if (!directory || directory->type != file::FileType::DIRECTORY) { //Should not happen
-        cerr << "Invalid upload file path!" << endl;
         return command_result{error::file_invalid_path, "could not resolve directory"};
     }
 

server/src/client/command_handler/helpers.h

@@ -137,6 +137,10 @@ inline bool permission_require_granted_value(ts::permission::PermissionType type
         case permission::i_client_max_permanent_channels:
         case permission::i_client_max_semi_channels:
         case permission::i_client_max_temporary_channels:
+        case permission::i_channel_create_modify_with_temp_delete_delay:
+        case permission::i_client_talk_power:
+        case permission::i_client_needed_talk_power:
+        case permission::b_channel_create_with_needed_talk_power:
 
         case permission::i_channel_max_depth:
         case permission::i_channel_min_depth:
@@ -146,6 +150,8 @@ inline bool permission_require_granted_value(ts::permission::PermissionType type
         case permission::i_max_playlist_size:
         case permission::i_max_playlists:
 
+        case permission::i_client_poke_max_clients:
+
         case permission::i_client_ban_max_bantime:
         case permission::i_client_max_idletime:
         case permission::i_group_sort_id:

server/src/client/command_handler/misc.cpp

@@ -13,7 +13,7 @@
 #include "../../build.h"
 #include "../ConnectedClient.h"
 #include "../InternalClient.h"
-#include "../../server/file/FileServer.h"
+#include "src/server/file/LocalFileServer.h"
 #include "../../server/VoiceServer.h"
 #include "../voice/VoiceClient.h"
 #include "PermissionManager.h"
@@ -366,7 +366,7 @@ command_result ConnectedClient::handleCommandPermissionList(Command &cmd) {
 
 #define M(ptype)                \
 do {                \
-    for(const auto& prop : property::impl::list<ptype>()) { \
+    for(const auto& prop : property::list<ptype>()) { \
         if((prop->flags & property::FLAG_INTERNAL) > 0) continue; \
         response[index]["name"] = prop->name; \
         response[index]["flags"] = prop->flags; \
@@ -767,7 +767,9 @@ command_result ConnectedClient::handleCommandBanClient(Command &cmd) {
     CMD_RESET_IDLE;
     CMD_CHK_AND_INC_FLOOD_POINTS(25);
 
-    string uid;
+    std::string target_unique_id{};
+    ClientDbId target_database_id{0};
+
     string reason = cmd[0].has("banreason") ? cmd["banreason"].string() : "";
     auto time = cmd[0].has("time") ? cmd["time"].as<uint64_t>() : 0UL;
     chrono::time_point<chrono::system_clock> until = time > 0 ? chrono::system_clock::now() + chrono::seconds(time) : chrono::time_point<chrono::system_clock>();
@@ -776,43 +778,40 @@ command_result ConnectedClient::handleCommandBanClient(Command &cmd) {
     const auto no_hwid = cmd.hasParm("no-hardware-id");
     const auto no_ip = cmd.hasParm("no-ip");
 
-    deque<shared_ptr<ConnectedClient>> target_clients;
+    std::deque<std::shared_ptr<ConnectedClient>> target_clients;
     if (cmd[0].has("uid")) {
-        target_clients = this->server->findClientsByUid(uid = cmd["uid"].string());
-        for(const auto& client : target_clients)
-            if(client->getType() == ClientType::CLIENT_MUSIC)
-                return command_result{error::client_invalid_id, "You cant ban a music bot!"};
+        target_clients = this->server->findClientsByUid(target_unique_id = cmd["uid"].string());
+    } else if(cmd[0].has("cldbid")) {
+        target_clients = this->server->findClientsByCldbId(target_database_id = cmd["cldbid"].as<ClientDbId>());
     } else {
         target_clients = {this->server->find_client_by_id(cmd["clid"].as<ClientId>())};
         if(!target_clients[0]) {
             return command_result{error::client_invalid_id, "Could not find target client"};
         }
-        if(target_clients[0]->getType() == ClientType::CLIENT_MUSIC) {
+    }
+
+    for(const auto& client : target_clients)
+        if(client->getType() == ClientType::CLIENT_MUSIC)
             return command_result{error::client_invalid_id, "You cant ban a music bot!"};
-        }
-        uid = target_clients[0]->getUid();
-    }
 
-    ClientDbId target_dbid = 0;
-    if (!target_clients.empty()) {
-        target_dbid = target_clients[0]->getClientDatabaseId();
-    } else {
-        auto info = serverInstance->databaseHelper()->queryDatabaseInfoByUid(this->getServer(), {uid});
-        if (!info.empty())
-            target_dbid = info[0]->cldbid;
-        else
-            return command_result{error::client_unknown};
-    }
+    if(!target_clients.empty()) {
+        if(target_unique_id.empty())
+            target_unique_id = target_clients.back()->getUid();
 
-    if(!permission::v2::permission_granted(this->server->calculate_permission(permission::i_client_needed_ban_power, target_dbid, ClientType::CLIENT_TEAMSPEAK, 0), this->calculate_permission(permission::i_client_ban_power, 0)))
+        if(!target_database_id)
+            target_database_id = target_clients.back()->getClientDatabaseId();
+    }
+    if(!permission::v2::permission_granted(this->server->calculate_permission(permission::i_client_needed_ban_power, target_database_id, ClientType::CLIENT_TEAMSPEAK, 0), this->calculate_permission(permission::i_client_ban_power, 0)))
         return command_result{permission::i_client_ban_power};
 
-    if (permission::v2::permission_granted(1, this->server->calculate_permission(permission::b_client_ignore_bans, target_dbid, ClientType::CLIENT_TEAMSPEAK, 0)))
+    if (permission::v2::permission_granted(1, this->server->calculate_permission(permission::b_client_ignore_bans, target_database_id, ClientType::CLIENT_TEAMSPEAK, 0)))
         return command_result{permission::b_client_ignore_bans};
 
     deque<BanId> ban_ids;
-    auto _id = serverInstance->banManager()->registerBan(this->getServer()->getServerId(), this->getClientDatabaseId(), reason, uid, "", "", "", until);
-    ban_ids.push_back(_id);
+    if(!target_unique_id.empty()) {
+        auto _id = serverInstance->banManager()->registerBan(this->getServer()->getServerId(), this->getClientDatabaseId(), reason, target_unique_id, "", "", "", until);
+        ban_ids.push_back(_id);
+    }
 
     auto b_ban_name = permission::v2::permission_granted(1, this->calculate_permission(permission::b_client_ban_name, 0), false);
     auto b_ban_ip = permission::v2::permission_granted(1, this->calculate_permission(permission::b_client_ban_ip, 0), false);
@@ -1329,7 +1328,9 @@ command_result ConnectedClient::handleCommandPermFind(Command &cmd) {
     CMD_CHK_AND_INC_FLOOD_POINTS(5);
     ACTION_REQUIRES_GLOBAL_PERMISSION(permission::b_virtualserver_permission_find, 1);
 
-    deque<pair<pair<string, permission::PermissionType>, bool>> permissions;
+    std::vector<std::tuple<std::string, permission::PermissionType, bool>> requested_permissions{};
+    requested_permissions.reserve(cmd.bulkCount());
+
     std::shared_ptr<permission::PermissionTypeEntry> permission;
     for(size_t index = 0; index < cmd.bulkCount(); index++) {
         bool granted = false;
@@ -1349,22 +1350,21 @@ command_result ConnectedClient::handleCommandPermFind(Command &cmd) {
             continue;
         }
 
-        permissions.emplace_back(pair<pair<string, permission::PermissionType>, bool>{{permission->name, permission->type}, granted});
+        requested_permissions.emplace_back(permission->name, permission->type, granted);
     }
 
-    if(permissions.empty())
+    if(requested_permissions.empty())
         return command_result{error::database_empty_result};
 
-    map<string, uint8_t> flags;
-    map<string, permission::PermissionType> quick_mapping;
-    string query_string;
-    for(const auto& entry : permissions) {
-        if(flags[entry.first.first] == 0) {
-            quick_mapping[entry.first.first] = entry.first.second;
-            query_string += string(query_string.empty() ? "" : " OR ") + "`permId` = '" + entry.first.first + "'";
+    std::map<std::string, std::tuple<permission::PermissionType, uint8_t>> db_lookup_mapping{};
+    std::string query_string{};
+    for(const auto& [name, id, as_granted] : requested_permissions) {
+        auto& mapping = db_lookup_mapping[name];
+        if(std::get<0>(mapping) == 0) {
+            std::get<0>(mapping) = id;
+            query_string += std::string{query_string.empty() ? "" : " OR "} + "`permId` = '" + name + "'";
         }
-
-        flags[entry.first.first] |= entry.second ? 2 : 1;
+        std::get<1>(mapping) |= (1U << as_granted);
     }
 
     deque<unique_ptr<PermissionEntry>> entries;
@@ -1373,13 +1373,14 @@ command_result ConnectedClient::handleCommandPermFind(Command &cmd) {
                  variable{":sid", this->server->getServerId()},
                  variable{":playlist", permission::SQL_PERM_PLAYLIST}
     ).query([&](int length, string* values, string* columns) {
-        permission::PermissionSqlType type = permission::SQL_PERM_GROUP;
-        uint64_t id = 0;
-        ChannelId channel_id = 0;
-        permission::PermissionValue value = 0,
-                granted_value = 0;
-        string permission_name;
+        permission::PermissionSqlType type{permission::SQL_PERM_GROUP};
+        uint64_t id{0};
+        ChannelId channel_id{0};
+        permission::PermissionValue value{0}, granted_value{0};
+        string permission_name{};
         bool negate = false, skip = false;
+
+#if 0
         for (int index = 0; index < length; index++) {
             try {
                 if(columns[index] == "type")
@@ -1403,35 +1404,48 @@ command_result ConnectedClient::handleCommandPermFind(Command &cmd) {
                 return 0;
             }
         }
+#else
+        assert(length == 8);
+        try {
+            type = static_cast<permission::PermissionSqlType>(stoll(values[1]));
+            permission_name = values[0];
+            id = static_cast<uint64_t>(stoll(values[2]));
+            channel_id = static_cast<ChannelId>(stoll(values[3]));
+            value = static_cast<permission::PermissionValue>(stoll(values[4]));
+            granted_value = static_cast<permission::PermissionValue>(stoll(values[5]));
+            negate = values[7] == "1";
+            skip = values[6] == "1";
+        } catch(std::exception& ex) {
+            return 0;
+        }
+#endif
 
+        auto request = db_lookup_mapping.find(permission_name);
+        if(request == db_lookup_mapping.end()) return 0; /* shall not happen */
+
+        auto flags = std::get<1>(request->second);
         /* value */
-        if((flags[permission_name] & 0x1) > 0 && value > 0) {
+        if((flags & 0x1U) > 0 && value > 0) {
             auto result = make_unique<PermissionEntry>();
-            result->permission_type = quick_mapping[permission_name];
+            result->permission_type = std::get<0>(request->second);
             result->permission_value = value;
             result->type = type;
             result->channel_id = channel_id;
             result->negate = negate;
             result->skip = skip;
             if (type == permission::SQL_PERM_GROUP) {
-                auto gr = this->server->groups->findGroup(id);
-                if (!gr) return 0;
-
                 result->group_id = id;
-                if(gr->target() == GROUPTARGET_CHANNEL)
-                    result->channel_id = 1;
             } else if(type == permission::SQL_PERM_USER) {
                 result->client_id = id;
             }
 
-            if(result)
-                entries.push_back(std::move(result));
+            entries.push_back(std::move(result));
         }
 
         /* granted */
-        if((flags[permission_name] & 0x2) > 0 && granted_value > 0) {
+        if((flags & 0x2U) > 0 && granted_value > 0) {
             auto result = make_unique<PermissionEntry>();
-            result->permission_type = (permission::PermissionType) (quick_mapping[permission_name] | PERM_ID_GRANT);
+            result->permission_type = (permission::PermissionType) (std::get<0>(request->second) | PERM_ID_GRANT);
             result->permission_value = granted_value;
             result->type = type;
             result->channel_id = channel_id;
@@ -1439,21 +1453,17 @@ command_result ConnectedClient::handleCommandPermFind(Command &cmd) {
             result->skip = skip;
 
             if (type == permission::SQL_PERM_GROUP) {
-                auto gr = this->server->groups->findGroup(id);
-                if (!gr) return 0;
-
                 result->group_id = id;
-                if(gr->target() == GROUPTARGET_CHANNEL)
-                    result->channel_id = 1;
             } else if(type == permission::SQL_PERM_USER) {
                 result->client_id = id;
             }
 
-            if(result)
-                entries.push_back(std::move(result));
+            entries.push_back(std::move(result));
         }
         return 0;
     });
+    if(entries.empty())
+        return command_result{error::database_empty_result};
 
     struct CommandPerm {
         permission::PermissionType p;
@@ -1465,13 +1475,13 @@ command_result ConnectedClient::handleCommandPermFind(Command &cmd) {
 
     std::vector<CommandPerm> perms;
     perms.resize(entries.size());
-    size_t index = 0;
+
+    size_t index{0};
+    auto all_groups = this->server->groups->availableGroups(true);
     for(const auto& entry : entries) {
         auto& perm = perms[index++];
 
-        perm.p = entry->permission_type;
-        perm.v = entry->permission_value;
-
+#if 0 /* TS3 switched the oder and YatQa as well, to keep compatibility we do it as well */
         if(entry->type == permission::SQL_PERM_USER) {
             if(entry->channel_id > 0) {
                 perm.id1 = entry->client_id;
@@ -1497,7 +1507,42 @@ command_result ConnectedClient::handleCommandPermFind(Command &cmd) {
                 perm.t = 0; /* server group */
             }
         }
+#else
+        if(entry->type == permission::SQL_PERM_USER) {
+            if(entry->channel_id > 0) {
+                perm.id1 = entry->channel_id;
+                perm.id2 = entry->client_id;
+                perm.t = 4; /* client channel */
+            } else {
+                perm.id1 = entry->client_id;
+                perm.id2 = 0;
+                perm.t = 1; /* client server */
+            }
+        } else if(entry->type == permission::SQL_PERM_CHANNEL) {
+            perm.id1 = entry->channel_id;
+            perm.id2 = 0;
+            perm.t = 2; /* channel permission */
+        } else if(entry->type == permission::SQL_PERM_GROUP) {
+            auto group = std::find_if(all_groups.begin(), all_groups.end(), [&](const auto& group) { return group->groupId() == entry->group_id; });
+            if(group == all_groups.end()) {
+                index--; /* unknown group */
+                continue;
+            }
+            if((*group)->target() == GroupTarget::GROUPTARGET_CHANNEL) {
+                perm.id1 = 0;
+                perm.id2 = entry->group_id;
+                perm.t = 3; /* channel group */
+            } else {
+                perm.id1 = entry->group_id;
+                perm.id2 = 0;
+                perm.t = 0; /* server group */
+            }
+        }
+#endif
+        perm.p = entry->permission_type;
+        perm.v = entry->permission_value;
     }
+    perms.erase(perms.begin() + index, perms.end());
 
 
     sort(perms.begin(), perms.end(), [](const CommandPerm& a, const CommandPerm& b) {
@@ -1516,6 +1561,7 @@ command_result ConnectedClient::handleCommandPermFind(Command &cmd) {
         return &a > &b;
     });
 
+#if 0
     Command result(this->notify_response_command("notifypermfind"));
     index = 0;
 
@@ -1528,9 +1574,22 @@ command_result ConnectedClient::handleCommandPermFind(Command &cmd) {
         result[index]["t"] = e.t;
         index++;
     }
-
-    if(index == 0) return command_result{error::database_empty_result};
     this->sendCommand(result);
+#else
+    command_builder result{this->notify_response_command("notifypermfind"), 64, perms.size()};
+    index = 0;
+
+    for(const auto& e : perms) {
+        auto bulk = result.bulk(index++);
+        bulk.put("t", e.t);
+        bulk.put("p", (uint16_t) e.p);
+        bulk.put("v", e.v);
+        bulk.put("id1", e.id1);
+        bulk.put("id2", e.id2);
+    }
+    this->sendCommand(result);
+#endif
+
     return command_result{error::ok};
 }
 
@@ -2088,6 +2147,7 @@ command_result ConnectedClient::handleCommandQueryCreate(ts::Command &cmd) {
     OptionalServerId server_id = this->getServerId();
     if(cmd[0].has("server_id"))
         server_id = cmd["server_id"];
+
     if(cmd[0].has("sid"))
         server_id = cmd["sid"];
 
@@ -2095,24 +2155,43 @@ command_result ConnectedClient::handleCommandQueryCreate(ts::Command &cmd) {
     if(!server && server_id != EmptyServerId && server_id != 0)
         return command_result{error::server_invalid_id};
 
-    if(server) {
-        if(!permission::v2::permission_granted(1, server->calculate_permission(permission::b_client_query_create, this->getClientDatabaseId(), this->getType(), 0)))
-            return command_result{permission::b_client_query_create};
-    } else {
-        if(!permission::v2::permission_granted(1, serverInstance->calculate_permission(permission::b_client_query_create, this->getClientDatabaseId(), this->getType(), 0)))
-            return command_result{permission::b_client_query_create};
-    }
-
     auto username = cmd["client_login_name"].as<string>();
     auto password = cmd[0].has("client_login_password") ? cmd["client_login_password"].as<string>() : "";
 
-    if(password.empty())
-        password = rnd_string(QUERY_PASSWORD_LENGTH);
-
     auto account = serverInstance->getQueryServer()->find_query_account_by_name(username);
     if(account) return command_result{error::query_already_exists};
 
-    account = serverInstance->getQueryServer()->create_query_account(username, server_id, this->getUid(), password);
+    std::string uid = this->getUid();
+    if(cmd[0].has("cldbid")){
+        if(!serverInstance->databaseHelper()->validClientDatabaseId(server, cmd["cldbid"].as<ClientDbId>()))
+            return command_result{error::database_empty_result};
+
+        if(server) {
+            if(!permission::v2::permission_granted(1, server->calculate_permission(permission::b_client_query_create, this->getClientDatabaseId(), this->getType(), 0)))
+                return command_result{permission::b_client_query_create};
+        } else {
+            if(!permission::v2::permission_granted(1, serverInstance->calculate_permission(permission::b_client_query_create, this->getClientDatabaseId(), this->getType(), 0)))
+                return command_result{permission::b_client_query_create};
+        }
+
+        auto info = serverInstance->databaseHelper()->queryDatabaseInfo(server, {cmd["cldbid"].as<ClientDbId>()});
+        if(info.empty())
+            return command_result{error::database_empty_result};
+        uid = info[0]->uniqueId;
+    } else {
+        if(server) {
+            if(!permission::v2::permission_granted(1, server->calculate_permission(permission::b_client_query_create_own, this->getClientDatabaseId(), this->getType(), 0)))
+                return command_result{permission::b_client_query_create_own};
+        } else {
+            if(!permission::v2::permission_granted(1, serverInstance->calculate_permission(permission::b_client_query_create_own, this->getClientDatabaseId(), this->getType(), 0)))
+                return command_result{permission::b_client_query_create_own};
+        }
+    }
+
+    if(password.empty())
+        password = rnd_string(QUERY_PASSWORD_LENGTH);
+
+    account = serverInstance->getQueryServer()->create_query_account(username, server_id, uid, password);
     if(!account)
         return command_result{error::vs_critical};
 
@@ -2262,7 +2341,7 @@ command_result ConnectedClient::handleCommandDummy_IpChange(ts::Command &cmd) {
     if(geoloc::provider) {
         auto loc = this->isAddressV4() ? geoloc::provider->resolveInfoV4(this->getPeerIp(), false) : geoloc::provider->resolveInfoV6(this->getPeerIp(), false);
         if(loc) {
-            logError(this->getServerId(), "[{}] Received new ip location. IP {} traced to {} ({}).", CLIENT_STR_LOG_PREFIX, this->getLoggingPeerIp(), loc->name, loc->identifier);
+            logMessage(this->getServerId(), "[{}] Received new ip location. IP {} traced to {} ({}).", CLIENT_STR_LOG_PREFIX, this->getLoggingPeerIp(), loc->name, loc->identifier);
             this->properties()[property::CLIENT_COUNTRY] = loc->identifier;
             server->notifyClientPropertyUpdates(_this.lock(),  deque<property::ClientProperties>{property::CLIENT_COUNTRY});
             new_country = loc->identifier;

server/src/client/command_handler/music.cpp

@@ -13,7 +13,7 @@
 #include "../../build.h"
 #include "../ConnectedClient.h"
 #include "../InternalClient.h"
-#include "../../server/file/FileServer.h"
+#include "src/server/file/LocalFileServer.h"
 #include "../../server/VoiceServer.h"
 #include "../voice/VoiceClient.h"
 #include "PermissionManager.h"
@@ -30,6 +30,7 @@
 #include <StringVariable.h>
 
 #include "helpers.h"
+#include "./bulk_parsers.h"
 
 #include <Properties.h>
 #include <log/LogUtils.h>
@@ -447,41 +448,41 @@ command_result ConnectedClient::handleCommandPlaylistEdit(ts::Command &cmd) {
     if(auto perr = playlist->client_has_permissions(this->ref(), permission::i_playlist_needed_modify_power, permission::i_playlist_modify_power); perr)
         return command_result{perr};
 
-    deque<pair<shared_ptr<property::PropertyDescription>, string>> properties;
+    deque<pair<const property::PropertyDescription*, string>> properties;
 
     for(const auto& key : cmd[0].keys()) {
         if(key == "playlist_id") continue;
         if(key == "return_code") continue;
 
-        auto property = property::info<property::PlaylistProperties>(key);
-        if(*property == property::PLAYLIST_UNDEFINED) {
+        const auto& property = property::find<property::PlaylistProperties>(key);
+        if(property == property::PLAYLIST_UNDEFINED) {
             logError(this->getServerId(), R"([{}] Tried to edit a not existing playlist property "{}" to "{}")", CLIENT_STR_LOG_PREFIX, key, cmd[key].string());
             continue;
         }
 
-        if((property->flags & property::FLAG_USER_EDITABLE) == 0) {
+        if((property.flags & property::FLAG_USER_EDITABLE) == 0) {
             logError(this->getServerId(), "[{}] Tried to change a playlist property which is not changeable. (Key: {}, Value: \"{}\")", CLIENT_STR_LOG_PREFIX, key, cmd[key].string());
             continue;
         }
 
-        if(!property->validate_input(cmd[key].as<string>())) {
+        if(!property.validate_input(cmd[key].as<string>())) {
             logError(this->getServerId(), "[{}] Tried to change a playlist property to an invalid value. (Key: {}, Value: \"{}\")", CLIENT_STR_LOG_PREFIX, key, cmd[key].string());
             continue;
         }
 
-        if(*property == property::PLAYLIST_CURRENT_SONG_ID) {
+        if(property == property::PLAYLIST_CURRENT_SONG_ID) {
             auto song_id = cmd[key].as<SongId>();
             auto song = song_id > 0 ? playlist->find_song(song_id) : nullptr;
             if(song_id != 0 && !song)
                 return command_result{error::playlist_invalid_song_id};
-        } else if(*property == property::PLAYLIST_MAX_SONGS) {
+        } else if(property == property::PLAYLIST_MAX_SONGS) {
             auto value = cmd[key].as<int32_t>();
             auto max_value = this->calculate_permission(permission::i_max_playlist_size, this->getChannelId());
             if(max_value.has_value && !permission::v2::permission_granted(value, max_value))
                 return command_result{permission::i_max_playlist_size};
         }
 
-        properties.emplace_back(property, key);
+        properties.emplace_back(&property, key);
     }
     for(const auto& property : properties) {
         if(*property.first == property::PLAYLIST_CURRENT_SONG_ID) {
@@ -558,35 +559,14 @@ command_result ConnectedClient::handleCommandPlaylistAddPerm(ts::Command &cmd) {
     if(auto perr = playlist->client_has_permissions(this->ref(), permission::i_playlist_needed_permission_modify_power, permission::i_playlist_permission_modify_power); perr)
         return command_result{perr};
 
-    auto max_value = this->calculate_permission(permission::i_permission_modify_power, 0, true);
-    if(!max_value.has_value) return command_result{permission::i_permission_modify_power};
+    command::bulk_parser::PermissionBulksParser<true> pparser{cmd};
+    if(!pparser.validate(this->ref(), 0))
+        return pparser.build_command_result();
 
-    auto ignore_granted_values = permission::v2::permission_granted(1, this->calculate_permission(permission::b_permission_modify_power_ignore, 0));
+    for(const auto& ppermission : pparser.iterate_valid_permissions())
+        ppermission.apply_to(playlist->permission_manager(), permission::v2::PermissionUpdateType::set_value);
 
-
-    bool conOnError = cmd[0].has("continueonerror");
-    for (int index = 0; index < cmd.bulkCount(); index++) {
-        PARSE_PERMISSION(cmd);
-
-        auto val = cmd[index]["permvalue"].as<permission::PermissionValue>();
-        if(permission_require_granted_value(permType) && !permission::v2::permission_granted(val, max_value)) {
-            if(conOnError) continue;
-            return command_result{permission::i_permission_modify_power};
-        }
-
-        if(!ignore_granted_values && !permission::v2::permission_granted(1, this->calculate_permission(permType, 0, true))) {
-            if(conOnError) continue;
-            return command_result{permission::i_permission_modify_power};
-        }
-
-        if (grant) {
-            playlist->permission_manager()->set_permission(permType, {0, cmd[index]["permvalue"]}, permission::v2::do_nothing, permission::v2::set_value);
-        } else {
-            playlist->permission_manager()->set_permission(permType, {cmd[index]["permvalue"],0}, permission::v2::set_value, permission::v2::do_nothing, cmd[index]["permskip"].as<bool>(), cmd[index]["permnegated"].as<bool>());
-        }
-    }
-
-    return command_result{error::ok};
+    return pparser.build_command_result();
 }
 
 command_result ConnectedClient::handleCommandPlaylistDelPerm(ts::Command &cmd) {
@@ -600,26 +580,14 @@ command_result ConnectedClient::handleCommandPlaylistDelPerm(ts::Command &cmd) {
     if(auto perr = playlist->client_has_permissions(this->ref(), permission::i_playlist_needed_permission_modify_power, permission::i_playlist_permission_modify_power); perr)
         return command_result{perr};
 
-    auto ignore_granted_values = permission::v2::permission_granted(1, this->calculate_permission(permission::b_permission_modify_power_ignore, 0));
-    bool conOnError = cmd[0].has("continueonerror");
+    command::bulk_parser::PermissionBulksParser<false> pparser{cmd};
+    if(!pparser.validate(this->ref(), 0))
+        return pparser.build_command_result();
 
-    for (int index = 0; index < cmd.bulkCount(); index++) {
-        PARSE_PERMISSION(cmd);
+    for(const auto& ppermission : pparser.iterate_valid_permissions())
+        ppermission.apply_to(playlist->permission_manager(), permission::v2::PermissionUpdateType::delete_value);
 
-        if(!ignore_granted_values && !permission::v2::permission_granted(0, this->calculate_permission(permType, 0, true))) {
-            if(conOnError) continue;
-            return command_result{permission::i_permission_modify_power};
-        }
-
-
-        if (grant) {
-            playlist->permission_manager()->set_permission(permType, {0, 0}, permission::v2::do_nothing, permission::v2::delete_value);
-        } else {
-            playlist->permission_manager()->set_permission(permType, {0, 0}, permission::v2::delete_value, permission::v2::do_nothing);
-        }
-    }
-
-    return command_result{error::ok};
+    return pparser.build_command_result();
 }
 
 command_result ConnectedClient::handleCommandPlaylistClientList(ts::Command &cmd) {
@@ -735,34 +703,14 @@ command_result ConnectedClient::handleCommandPlaylistClientAddPerm(ts::Command &
     if(auto perr = playlist->client_has_permissions(this->ref(), permission::i_playlist_needed_permission_modify_power, permission::i_playlist_permission_modify_power); perr)
         return command_result{perr};
 
-    auto max_value = this->calculate_permission(permission::i_permission_modify_power, 0, true);
-    if(!max_value.has_value) return command_result{permission::i_permission_modify_power};
+    command::bulk_parser::PermissionBulksParser<true> pparser{cmd};
+    if(!pparser.validate(this->ref(), this->getClientDatabaseId()))
+        return pparser.build_command_result();
 
-    auto ignore_granted_values = permission::v2::permission_granted(1, this->calculate_permission(permission::b_permission_modify_power_ignore, 0));
+    for(const auto& ppermission : pparser.iterate_valid_permissions())
+        ppermission.apply_to_channel(playlist->permission_manager(), permission::v2::PermissionUpdateType::set_value, client_id);
 
-    bool conOnError = cmd[0].has("continueonerror");
-    for (int index = 0; index < cmd.bulkCount(); index++) {
-        PARSE_PERMISSION(cmd);
-
-        auto val = cmd[index]["permvalue"].as<permission::PermissionValue>();
-        if(permission_require_granted_value(permType) && !permission::v2::permission_granted(val, max_value)) {
-            if(conOnError) continue;
-            return command_result{permission::i_permission_modify_power};
-        }
-
-        if(!ignore_granted_values && !permission::v2::permission_granted(1, this->calculate_permission(permType, 0, true))) {
-            if(conOnError) continue;
-            return command_result{permission::i_permission_modify_power};
-        }
-
-        if (grant) {
-            playlist->permission_manager()->set_channel_permission(permType, client_id, {0, cmd[index]["permvalue"]}, permission::v2::do_nothing, permission::v2::set_value);
-        } else {
-            playlist->permission_manager()->set_channel_permission(permType, client_id, {cmd[index]["permvalue"], 0}, permission::v2::set_value, permission::v2::do_nothing, cmd[index]["permskip"].as<bool>(), cmd[index]["permnegated"].as<bool>());
-        }
-    }
-
-    return command_result{error::ok};
+    return pparser.build_command_result();
 }
 
 command_result ConnectedClient::handleCommandPlaylistClientDelPerm(ts::Command &cmd) {
@@ -779,26 +727,53 @@ command_result ConnectedClient::handleCommandPlaylistClientDelPerm(ts::Command &
     if(auto perr = playlist->client_has_permissions(this->ref(), permission::i_playlist_needed_permission_modify_power, permission::i_playlist_permission_modify_power); perr)
         return command_result{perr};
 
-    auto ignore_granted_values = permission::v2::permission_granted(1, this->calculate_permission(permission::b_permission_modify_power_ignore, 0));
-    bool conOnError = cmd[0].has("continueonerror");
 
-    for (int index = 0; index < cmd.bulkCount(); index++) {
-        PARSE_PERMISSION(cmd);
+    command::bulk_parser::PermissionBulksParser<false> pparser{cmd};
+    if(!pparser.validate(this->ref(), this->getClientDatabaseId()))
+        return pparser.build_command_result();
 
-        if(!ignore_granted_values && !permission::v2::permission_granted(0, this->calculate_permission(permType, 0, true))) {
-            if(conOnError) continue;
-            return command_result{permission::i_permission_modify_power};
-        }
+    for(const auto& ppermission : pparser.iterate_valid_permissions())
+        ppermission.apply_to_channel(playlist->permission_manager(), permission::v2::PermissionUpdateType::delete_value, client_id);
 
+    return pparser.build_command_result();
+}
 
-        if (grant) {
-            playlist->permission_manager()->set_channel_permission(permType, client_id, {0, 0}, permission::v2::do_nothing, permission::v2::delete_value);
-        } else {
-            playlist->permission_manager()->set_channel_permission(permType, client_id, {0, 0}, permission::v2::delete_value, permission::v2::do_nothing);
-        }
+constexpr auto max_song_meta_info = 1024 * 512;
+
+inline size_t estimated_song_info_size(const std::shared_ptr<ts::music::PlaylistEntryInfo>& song, bool extract_metadata) {
+    return 128 + std::min(song->metadata.json_string.length(), (size_t) max_song_meta_info) + extract_metadata * 256;
+}
+
+inline void fill_song_info(ts::command_builder_bulk bulk, const std::shared_ptr<ts::music::PlaylistEntryInfo>& song, bool extract_metadata) {
+    bulk.reserve(estimated_song_info_size(song, extract_metadata));
+
+    bulk.put("song_id", song->song_id);
+    bulk.put("song_invoker", song->invoker);
+    bulk.put("song_previous_song_id", song->previous_song_id);
+    bulk.put("song_url", song->original_url);
+    bulk.put("song_url_loader", song->url_loader);
+    bulk.put("song_loaded", song->metadata.is_loaded());
+    if(song->metadata.json_string.length() > 1024 * 1024 * 512) {
+        logWarning(LOG_GENERAL, "Dropping song metadata because its way to big. ({}bytes)", song->metadata.json_string.size());
+    } else {
+        bulk.put("song_metadata", song->metadata.json_string);
     }
 
-    return command_result{error::ok};
+    if(extract_metadata) {
+        bulk.reserve(256, true);
+        auto metadata = song->metadata.loaded_data;
+        if(extract_metadata && song->metadata.is_loaded() && metadata) {
+            bulk.put("song_metadata_title", metadata->title);
+            bulk.put("song_metadata_description", metadata->description);
+            bulk.put("song_metadata_url", metadata->url);
+            bulk.put("song_metadata_length", metadata->length.count());
+            if(auto thumbnail = static_pointer_cast<::music::ThumbnailUrl>(metadata->thumbnail); thumbnail && thumbnail->type() == ::music::THUMBNAIL_URL) {
+                bulk.put("song_metadata_thumbnail_url", thumbnail->url());
+            } else {
+                bulk.put("song_metadata_thumbnail_url", "none");
+            }
+        }
+    }
 }
 
 command_result ConnectedClient::handleCommandPlaylistSongList(ts::Command &cmd) {
@@ -816,39 +791,32 @@ command_result ConnectedClient::handleCommandPlaylistSongList(ts::Command &cmd)
     if(songs.empty())
         return command_result{error::database_empty_result};
 
-    Command notify(this->notify_response_command("notifyplaylistsonglist"));
-    notify["playlist_id"] = playlist->playlist_id();
-
+    ts::command_builder result{this->notify_response_command("notifyplaylistsonglist")};
+    result.put(0, "version", 2); /* to signalize that we're sending the response bulked */
     auto extract_metadata = cmd.hasParm("extract-metadata");
 
-    size_t index = 0;
+    size_t index{0};
     for(const auto& song : songs) {
-        notify[index]["song_id"] = song->song_id;
-        notify[index]["song_invoker"] = song->invoker;
-        notify[index]["song_previous_song_id"] = song->previous_song_id;
-        notify[index]["song_url"] = song->original_url;
-        notify[index]["song_url_loader"] = song->url_loader;
-        notify[index]["song_loaded"] = song->metadata.is_loaded();
-        notify[index]["song_metadata"] = song->metadata.json_string;
-
-        if(extract_metadata) {
-            auto metadata = song->metadata.loaded_data;
-            if(extract_metadata && song->metadata.is_loaded() && metadata) {
-                notify[index]["song_metadata_title"] = metadata->title;
-                notify[index]["song_metadata_description"] = metadata->description;
-                notify[index]["song_metadata_url"] = metadata->url;
-                notify[index]["song_metadata_length"] = metadata->length.count();
-                if(auto thumbnail = static_pointer_cast<::music::ThumbnailUrl>(metadata->thumbnail); thumbnail && thumbnail->type() == ::music::THUMBNAIL_URL) {
-                    notify[index]["song_metadata_thumbnail_url"] = thumbnail->url();
-                } else {
-                    notify[index]["song_metadata_thumbnail_url"] = "none";
-                }
-            }
+        if(index == 0) {
+            result.put(0, "playlist_id", playlist->playlist_id());
         }
+        fill_song_info(result.bulk(index), song, extract_metadata);
 
-        index++;
+        if(this->getExternalType() == ClientType::CLIENT_TEAMSPEAK && result.current_size() + estimated_song_info_size(song, extract_metadata) > 128 * 1024) {
+            this->sendCommand(result);
+            result.reset();
+            index = 0;
+        } else {
+            index++;
+        }
+    }
+    if(index > 0)
+        this->sendCommand(result);
+    if(this->getExternalType() == ClientType::CLIENT_TEAMSPEAK) {
+        ts::command_builder finish{"notifyplaylistsonglistfinished"};
+        finish.put(0, "playlist_id", playlist->playlist_id());
+        this->sendCommand(finish);
     }
-    this->sendCommand(notify);
 
     return command_result{error::ok};
 }

server/src/client/command_handler/server.cpp

@@ -4,19 +4,15 @@
 
 #include <memory>
 
-#include <spdlog/sinks/rotating_file_sink.h>
-
-#include <iostream>
 #include <bitset>
 #include <algorithm>
 #include <openssl/sha.h>
 #include "../../build.h"
 #include "../ConnectedClient.h"
 #include "../InternalClient.h"
-#include "../../server/file/FileServer.h"
+#include "src/server/file/LocalFileServer.h"
 #include "../../server/VoiceServer.h"
 #include "../voice/VoiceClient.h"
-#include "PermissionManager.h"
 #include "../../InstanceHandler.h"
 #include "../../server/QueryServer.h"
 #include "../file/FileClient.h"
@@ -25,25 +21,17 @@
 #include "../../weblist/WebListManager.h"
 #include "../../manager/ConversationManager.h"
 #include "../../manager/PermissionNameMapper.h"
-#include <experimental/filesystem>
-#include <cstdint>
-#include <StringVariable.h>
 
 #include "helpers.h"
+#include "./bulk_parsers.h"
 
-#include <Properties.h>
 #include <log/LogUtils.h>
-#include <misc/sassert.h>
 #include <misc/base64.h>
-#include <misc/hex.h>
 #include <misc/digest.h>
 #include <misc/rnd.h>
-#include <misc/timer.h>
-#include <misc/strobf.h>
 #include <misc/scope_guard.h>
 #include <bbcode/bbcodes.h>
 
-namespace fs = std::experimental::filesystem;
 using namespace std::chrono;
 using namespace std;
 using namespace ts;
@@ -224,14 +212,14 @@ command_result ConnectedClient::handleCommandServerEdit(Command &cmd) {
     std::deque<std::string> keys;
     bool group_update = false;
     for (const auto& elm : toApplay) {
-        auto info = property::impl::info<property::VirtualServerProperties>(elm.first);
-        if(*info == property::VIRTUALSERVER_UNDEFINED) {
+        const auto& info = property::find<property::VirtualServerProperties>(elm.first);
+        if(info == property::VIRTUALSERVER_UNDEFINED) {
             logCritical(target_server ? target_server->getServerId() : 0, "Missing server property " + elm.first);
             continue;
         }
 
-        if(!info->validate_input(elm.second)) {
-            logError(target_server ? target_server->getServerId() : 0, "Client " + this->getDisplayName() + " tried to change a property to an invalid value. (Value: '" + elm.second + "', Property: '" + info->name + "')");
+        if(!info.validate_input(elm.second)) {
+            logError(target_server ? target_server->getServerId() : 0, "Client " + this->getDisplayName() + " tried to change a property to an invalid value. (Value: '" + elm.second + "', Property: '" + std::string{info.name} + "')");
             continue;
         }
         if(target_server)
@@ -240,7 +228,7 @@ command_result ConnectedClient::handleCommandServerEdit(Command &cmd) {
             (*serverInstance->getDefaultServerProperties())[info] = elm.second;
         keys.push_back(elm.first);
 
-        group_update |= *info == property::VIRTUALSERVER_DEFAULT_SERVER_GROUP || *info == property::VIRTUALSERVER_DEFAULT_CHANNEL_GROUP || *info == property::VIRTUALSERVER_DEFAULT_MUSIC_GROUP;
+        group_update |= info == property::VIRTUALSERVER_DEFAULT_SERVER_GROUP || info == property::VIRTUALSERVER_DEFAULT_CHANNEL_GROUP || info == property::VIRTUALSERVER_DEFAULT_MUSIC_GROUP;
     }
 
     if(target_server) {
@@ -262,35 +250,38 @@ command_result ConnectedClient::handleCommandServerRequestConnectionInfo(Command
     CMD_REQ_SERVER;
     ACTION_REQUIRES_GLOBAL_PERMISSION(permission::b_virtualserver_connectioninfo_view, 1);
 
-    Command notify("notifyserverconnectioninfo");
+    ts::command_builder result{"notifyserverconnectioninfo"};
+    auto first_bulk = result.bulk(0);
 
-    auto statistics = this->server->getServerStatistics()->statistics();
-    auto report = this->server->getServerStatistics()->dataReport();
+    auto total_stats = this->server->getServerStatistics()->total_stats();
+    auto minute_report = this->server->getServerStatistics()->minute_stats();
+    auto second_report = this->server->getServerStatistics()->second_stats();
+    auto network_report = this->server->generate_network_report();
 
-    notify[0]["connection_filetransfer_bandwidth_sent"] = report.file_send;
-    notify[0]["connection_filetransfer_bandwidth_received"] = report.file_recv;
+    first_bulk.put_unchecked(property::CONNECTION_FILETRANSFER_BANDWIDTH_SENT, minute_report.file_bytes_sent);
+    first_bulk.put_unchecked(property::CONNECTION_FILETRANSFER_BANDWIDTH_RECEIVED, minute_report.file_bytes_received);
 
-    notify[0]["connection_filetransfer_bytes_sent_total"] = (*statistics)[property::CONNECTION_FILETRANSFER_BYTES_SENT_TOTAL].as<string>();
-    notify[0]["connection_filetransfer_bytes_received_total"] = (*statistics)[property::CONNECTION_FILETRANSFER_BYTES_RECEIVED_TOTAL].as<string>();
+    first_bulk.put_unchecked(property::CONNECTION_FILETRANSFER_BYTES_SENT_TOTAL, minute_report.file_bytes_sent);
+    first_bulk.put_unchecked(property::CONNECTION_FILETRANSFER_BYTES_RECEIVED_TOTAL, minute_report.file_bytes_received);
 
-    notify[0]["connection_filetransfer_bytes_sent_month"] = this->server->properties()[property::VIRTUALSERVER_MONTH_BYTES_DOWNLOADED].as<string>();
-    notify[0]["connection_filetransfer_bytes_received_month"] = this->server->properties()[property::VIRTUALSERVER_MONTH_BYTES_UPLOADED].as<string>();
+    first_bulk.put_unchecked("connection_filetransfer_bytes_sent_month", this->server->properties()[property::VIRTUALSERVER_MONTH_BYTES_DOWNLOADED].as<string>());
+    first_bulk.put_unchecked("connection_filetransfer_bytes_received_month", this->server->properties()[property::VIRTUALSERVER_MONTH_BYTES_UPLOADED].as<string>());
 
-    notify[0]["connection_packets_sent_total"] = (*statistics)[property::CONNECTION_PACKETS_SENT_TOTAL].as<string>();
-    notify[0]["connection_bytes_sent_total"] = (*statistics)[property::CONNECTION_BYTES_SENT_TOTAL].as<string>();
-    notify[0]["connection_packets_received_total"] = (*statistics)[property::CONNECTION_PACKETS_RECEIVED_TOTAL].as<string>();
-    notify[0]["connection_bytes_received_total"] = (*statistics)[property::CONNECTION_BYTES_RECEIVED_TOTAL].as<string>();
+    first_bulk.put_unchecked(property::CONNECTION_PACKETS_SENT_TOTAL, std::accumulate(total_stats.connection_packets_sent.begin(), total_stats.connection_packets_sent.end(), (size_t) 0U));
+    first_bulk.put_unchecked(property::CONNECTION_BYTES_SENT_TOTAL, std::accumulate(total_stats.connection_bytes_sent.begin(), total_stats.connection_bytes_sent.end(), (size_t) 0U));
+    first_bulk.put_unchecked(property::CONNECTION_PACKETS_RECEIVED_TOTAL, std::accumulate(total_stats.connection_packets_received.begin(), total_stats.connection_packets_received.end(), (size_t) 0U));
+    first_bulk.put_unchecked(property::CONNECTION_BYTES_RECEIVED_TOTAL, std::accumulate(total_stats.connection_bytes_received.begin(), total_stats.connection_bytes_received.end(), (size_t) 0U));
 
-    notify[0]["connection_bandwidth_sent_last_second_total"] = report.send_second;
-    notify[0]["connection_bandwidth_sent_last_minute_total"] = report.send_minute;
-    notify[0]["connection_bandwidth_received_last_second_total"] = report.recv_second;
-    notify[0]["connection_bandwidth_received_last_minute_total"] = report.recv_minute;
+    first_bulk.put_unchecked(property::CONNECTION_BANDWIDTH_SENT_LAST_SECOND_TOTAL, std::accumulate(second_report.connection_bytes_sent.begin(), second_report.connection_bytes_sent.end(), (size_t) 0U));
+    first_bulk.put_unchecked(property::CONNECTION_BANDWIDTH_SENT_LAST_MINUTE_TOTAL, std::accumulate(minute_report.connection_bytes_sent.begin(), minute_report.connection_bytes_sent.end(), (size_t) 0U));
+    first_bulk.put_unchecked(property::CONNECTION_BANDWIDTH_RECEIVED_LAST_SECOND_TOTAL, std::accumulate(second_report.connection_bytes_received.begin(), second_report.connection_bytes_received.end(), (size_t) 0U));
+    first_bulk.put_unchecked(property::CONNECTION_BANDWIDTH_RECEIVED_LAST_MINUTE_TOTAL, std::accumulate(minute_report.connection_bytes_received.begin(), minute_report.connection_bytes_received.end(), (size_t) 0U));
 
-    notify[0]["connection_connected_time"] = this->server->properties()[property::VIRTUALSERVER_UPTIME].as<string>();
-    notify[0]["connection_packetloss_total"] = this->server->averagePacketLoss();
-    notify[0]["connection_ping"] = this->server->averagePing();
+    first_bulk.put_unchecked(property::CONNECTION_CONNECTED_TIME, this->server->properties()[property::VIRTUALSERVER_UPTIME].as<string>());
+    first_bulk.put_unchecked(property::CONNECTION_PACKETLOSS_TOTAL, network_report.average_loss);
+    first_bulk.put_unchecked(property::CONNECTION_PING, network_report.average_ping);
 
-    this->sendCommand(notify);
+    this->sendCommand(result);
     return command_result{error::ok};
 }
 
@@ -547,7 +538,7 @@ command_result ConnectedClient::handleCommandServerGroupAddClient(Command &cmd)
     auto continue_on_error = cmd.hasParm("continueonerror");
     {
         auto permission_add_power = this->calculate_permission(permission::i_server_group_member_add_power, -1);
-        auto permission_self_add_power = this->calculate_permission(permission::i_server_group_member_add_power, -1);
+        auto permission_self_add_power = this->calculate_permission(permission::i_server_group_self_add_power, -1);
 
         for(auto index = 0; index < cmd.bulkCount(); index++) {
             auto group_id = cmd[index]["sgid"];
@@ -663,7 +654,7 @@ command_result ConnectedClient::handleCommandServerGroupDelClient(Command &cmd)
     auto continue_on_error = cmd.hasParm("continueonerror");
     {
         auto permission_remove_power = this->calculate_permission(permission::i_server_group_member_remove_power, -1);
-        auto permission_self_remove_power = this->calculate_permission(permission::i_server_group_member_remove_power, -1);
+        auto permission_self_remove_power = this->calculate_permission(permission::i_server_group_self_remove_power, -1);
 
         for(auto index = 0; index < cmd.bulkCount(); index++) {
             auto group_id = cmd[index]["sgid"];
@@ -751,6 +742,9 @@ command_result ConnectedClient::handleCommandServerGroupDelClient(Command &cmd)
 
     for(const auto& _server : target_server ? std::deque<shared_ptr<VirtualServer>>{target_server} : serverInstance->getVoiceServerManager()->serverInstances()) {
         for (const auto &targetClient : _server->findClientsByCldbId(target_cldbid)) {
+            ConnectedLockedClient clock{targetClient};
+            if(!clock) continue;
+            
             if (_server->notifyClientPropertyUpdates(targetClient, _server->groups->update_server_group_property(targetClient, true, targetClient->getChannel()))) {
                 for (const auto &client : _server->getClients()) {
                     if(client->isClientVisible(targetClient, true) || client == targetClient)
@@ -799,73 +793,43 @@ command_result ConnectedClient::handleCommandServerGroupAddPerm(Command &cmd) {
         ACTION_REQUIRES_GLOBAL_PERMISSION(permission::b_serverinstance_modify_templates, 1);
     }
 
+    command::bulk_parser::PermissionBulksParser<true> pparser{cmd};
+    if(!pparser.validate(this->ref(), 0))
+        return pparser.build_command_result();
 
-    auto max_value = this->calculate_permission(permission::i_permission_modify_power, 0, true);
-    if(!max_value.has_value) return command_result{permission::i_permission_modify_power};
-
-    auto ignore_granted_values = permission::v2::permission_granted(1, this->calculate_permission(permission::b_permission_modify_power_ignore, 0));
-
-    bool conOnError = cmd[0].has("continueonerror");
-    bool checkTp = false;
-    bool sgroupUpdate = false;
-
+    bool update_talk_power{false}, update_server_group_list{false};
     auto permissions = serverGroup->permissions();
-    for (int index = 0; index < cmd.bulkCount(); index++) {
-        PARSE_PERMISSION(cmd);
-        //permvalue='1' permnegated='0' permskip='0'
-
-        auto val = cmd[index]["permvalue"].as<permission::PermissionValue>();
-        if(permission_require_granted_value(permType) && !permission::v2::permission_granted(val, max_value)) {
-            if(conOnError) continue;
-            return command_result{permission::i_permission_modify_power};
-        }
-
-        if(!ignore_granted_values && !permission::v2::permission_granted(1, this->calculate_permission(permType, 0, true))) {
-            if(conOnError) continue;
-            return command_result{permission::i_permission_modify_power};
-        }
-
-        if (grant) {
-            permissions->set_permission(permType, {0, cmd[index]["permvalue"]}, permission::v2::PermissionUpdateType::do_nothing, permission::v2::PermissionUpdateType::set_value);
-        } else {
-            permissions->set_permission(
-                    permType,
-                    {cmd[index]["permvalue"], 0},
-                    permission::v2::PermissionUpdateType::set_value,
-                    permission::v2::PermissionUpdateType::do_nothing,
-
-                    cmd[index]["permskip"].as<bool>() ? 1 : 0,
-                    cmd[index]["permnegated"].as<bool>() ? 1 : 0
-            );
-            sgroupUpdate |= permission_is_group_property(permType);
-            checkTp |= permission_is_client_property(permType);
-        }
+    for(const auto& ppermission : pparser.iterate_valid_permissions()) {
+        ppermission.apply_to(serverGroup->permissions(), permission::v2::PermissionUpdateType::set_value);
+        update_server_group_list |= ppermission.is_group_property();
+        update_talk_power |= ppermission.is_client_view_property();
     }
 
-    if(sgroupUpdate)
+    if(update_server_group_list)
         serverGroup->apply_properties_from_permissions();
 
     //TODO may update for every server?
     if(this->server) {
         auto lock = this->_this.lock();
         auto server = this->server;
-        threads::Thread([checkTp, sgroupUpdate, serverGroup, lock, server]() {
-            if(sgroupUpdate)
+        threads::Thread([update_talk_power, update_server_group_list, serverGroup, lock, server]() {
+            if(update_server_group_list)
                 server->forEachClient([](shared_ptr<ConnectedClient> cl) {
                     cl->notifyServerGroupList();
                 });
-            server->forEachClient([serverGroup, checkTp](shared_ptr<ConnectedClient> cl) {
+            server->forEachClient([serverGroup, update_talk_power](shared_ptr<ConnectedClient> cl) {
                 if (cl->serverGroupAssigned(serverGroup)) {
                     if(cl->update_cached_permissions()) /* update cached calculated permissions */
                         cl->sendNeededPermissions(false); /* cached permissions had changed, notify the client */
-                    if (checkTp)
+                    if (update_talk_power)
                         cl->updateChannelClientProperties(true, true);
                     cl->join_state_id++; /* join permission may changed, all channels need to be recalculate dif needed */
                 }
             });
         }).detach();
     }
-    return command_result{error::ok};
+
+    return pparser.build_command_result();
 }
 
 command_result ConnectedClient::handleCommandServerGroupDelPerm(Command &cmd) {
@@ -884,49 +848,34 @@ command_result ConnectedClient::handleCommandServerGroupDelPerm(Command &cmd) {
         ACTION_REQUIRES_GLOBAL_PERMISSION(permission::b_serverinstance_modify_templates, 1);
     }
 
-    auto ignore_granted_values = permission::v2::permission_granted(1, this->calculate_permission(permission::b_permission_modify_power_ignore, 0));
-    bool conOnError = cmd[0].has("continueonerror");
-    bool checkTp = false;
-    auto sgroupUpdate = false;
-    for (int index = 0; index < cmd.bulkCount(); index++) {
-        PARSE_PERMISSION(cmd);
+    command::bulk_parser::PermissionBulksParser<false> pparser{cmd};
+    if(!pparser.validate(this->ref(), 0))
+        return pparser.build_command_result();
 
-        if(!ignore_granted_values && !permission::v2::permission_granted(0, this->calculate_permission(permType, 0, true))) {
-            if(conOnError) continue;
-            return command_result{permission::i_permission_modify_power};
-        }
-
-        if (grant) {
-            serverGroup->permissions()->set_permission(permType, permission::v2::empty_permission_values, permission::v2::PermissionUpdateType::do_nothing, permission::v2::PermissionUpdateType::delete_value);
-        } else {
-            serverGroup->permissions()->set_permission(
-                    permType,
-                    permission::v2::empty_permission_values,
-                    permission::v2::PermissionUpdateType::delete_value,
-                    permission::v2::PermissionUpdateType::do_nothing
-            );
-            sgroupUpdate |= permission_is_group_property(permType);
-            checkTp |= permission_is_client_property(permType);
-        }
+    bool update_talk_power{false}, update_server_group_list{false};
+    for(const auto& ppermission : pparser.iterate_valid_permissions()) {
+        ppermission.apply_to(serverGroup->permissions(), permission::v2::PermissionUpdateType::delete_value);
+        update_server_group_list |= ppermission.is_group_property();
+        update_talk_power |= ppermission.is_client_view_property();
     }
 
-    if(sgroupUpdate)
+    if(update_server_group_list)
         serverGroup->apply_properties_from_permissions();
 
     if(this->server) {
         auto lock = this->_this.lock();
         auto server = this->server;
-        threads::Thread([checkTp, sgroupUpdate, serverGroup, lock, server]() {
-            if(sgroupUpdate)
+        threads::Thread([update_talk_power, update_server_group_list, serverGroup, lock, server]() {
+            if(update_server_group_list)
                 server->forEachClient([](shared_ptr<ConnectedClient> cl) {
                     cl->notifyServerGroupList();
                 });
-            server->forEachClient([serverGroup, checkTp](shared_ptr<ConnectedClient> cl) {
+            server->forEachClient([serverGroup, update_talk_power](shared_ptr<ConnectedClient> cl) {
                 if (cl->serverGroupAssigned(serverGroup)) {
 
                     if(cl->update_cached_permissions()) /* update cached calculated permissions */
                         cl->sendNeededPermissions(false); /* cached permissions had changed, notify the client */
-                    if (checkTp)
+                    if (update_talk_power)
                         cl->updateChannelClientProperties(true, true);
                     cl->join_state_id++; /* join permission may changed, all channels need to be recalculate dif needed */
                 }
@@ -934,7 +883,7 @@ command_result ConnectedClient::handleCommandServerGroupDelPerm(Command &cmd) {
         }).detach();
     }
 
-    return command_result{error::ok};
+    return pparser.build_command_result();
 }
 
 command_result ConnectedClient::handleCommandServerGroupAutoAddPerm(ts::Command& cmd) {
@@ -964,67 +913,37 @@ command_result ConnectedClient::handleCommandServerGroupAutoAddPerm(ts::Command&
     if(groups.empty())
         return command_result{error::ok};
 
-    auto max_value = this->calculate_permission(permission::i_permission_modify_power, 0, true);
-    if(!max_value.has_value) return command_result{permission::i_permission_modify_power};
+    command::bulk_parser::PermissionBulksParser<true> pparser{cmd};
+    if(!pparser.validate(this->ref(), 0))
+        return pparser.build_command_result();
 
-    auto ignore_granted_values = permission::v2::permission_granted(1, this->calculate_permission(permission::b_permission_modify_power_ignore, 0));
+    bool update_clients{false}, update_server_group_list{false};
+    for(const auto& ppermission : pparser.iterate_valid_permissions()) {
+        for(const auto& serverGroup : groups)
+            ppermission.apply_to(serverGroup->permissions(), permission::v2::PermissionUpdateType::set_value);
 
-    bool conOnError = cmd[0].has("continueonerror");
-    bool checkTp = false;
-    bool sgroupUpdate = false;
-
-    for (int index = 0; index < cmd.bulkCount(); index++) {
-        PARSE_PERMISSION(cmd);
-        //permvalue='1' permnegated='0' permskip='0'end
-
-        auto val = cmd[index]["permvalue"].as<permission::PermissionValue>();
-        if(permission_require_granted_value(permType) && !permission::v2::permission_granted(val, max_value)) {
-            if(conOnError) continue;
-            return command_result{permission::i_permission_modify_power};
-        }
-
-        if(!ignore_granted_values && !permission::v2::permission_granted(1, this->calculate_permission(permType, 0, true))) {
-            if(conOnError) continue;
-            return command_result{permission::i_permission_modify_power};
-        }
-
-        for(const auto& serverGroup : groups) {
-            if (grant) {
-                serverGroup->permissions()->set_permission(permType, {0, cmd[index]["permvalue"]}, permission::v2::PermissionUpdateType::do_nothing, permission::v2::PermissionUpdateType::set_value);
-            } else {
-                serverGroup->permissions()->set_permission(
-                        permType,
-                        {cmd[index]["permvalue"], 0},
-                        permission::v2::PermissionUpdateType::set_value,
-                        permission::v2::PermissionUpdateType::do_nothing,
-
-                        cmd[index]["permskip"].as<bool>() ? 1 : 0,
-                        cmd[index]["permnegated"].as<bool>() ? 1 : 0
-                );
-            }
-        }
-        sgroupUpdate |= permission_is_group_property(permType);
-        checkTp |= permission_is_client_property(permType);
+        update_server_group_list |= ppermission.is_group_property();
+        update_clients |= ppermission.is_client_view_property();
     }
 
-    if(sgroupUpdate)
+    if(update_server_group_list)
         for(auto& group : groups)
             group->apply_properties_from_permissions();
 
     auto lock = this->_this.lock();
     if(ref_server) {
-        threads::Thread([checkTp, sgroupUpdate, groups, lock, ref_server]() {
-            if(sgroupUpdate)
+        threads::Thread([update_clients, update_server_group_list, groups, lock, ref_server]() {
+            if(update_server_group_list)
                 ref_server->forEachClient([](shared_ptr<ConnectedClient> cl) {
                     cl->notifyServerGroupList();
                 });
-            ref_server->forEachClient([groups, checkTp](shared_ptr<ConnectedClient> cl) {
+            ref_server->forEachClient([groups, update_clients](shared_ptr<ConnectedClient> cl) {
                 for(const auto& serverGroup : groups) {
                     if (cl->serverGroupAssigned(serverGroup)) {
                         if(cl->update_cached_permissions()) {/* update cached calculated permissions */
                             cl->sendNeededPermissions(false); /* cached permissions had changed, notify the client */
                         }
-                        if (checkTp) {
+                        if (update_clients) {
                             cl->updateChannelClientProperties(true, true);
                         }
                         cl->join_state_id++; /* join permission may changed, all channels need to be recalculate if needed */
@@ -1034,7 +953,8 @@ command_result ConnectedClient::handleCommandServerGroupAutoAddPerm(ts::Command&
             });
         }).detach();
     }
-    return command_result{error::ok};
+
+    return pparser.build_command_result();
 }
 
 command_result ConnectedClient::handleCommandServerGroupAutoDelPerm(ts::Command& cmd) {
@@ -1063,54 +983,37 @@ command_result ConnectedClient::handleCommandServerGroupAutoDelPerm(ts::Command&
 
     if(groups.empty()) return command_result{error::ok};
 
-    auto ignore_granted_values = permission::v2::permission_granted(1, this->calculate_permission(permission::b_permission_modify_power_ignore, 0));
+    command::bulk_parser::PermissionBulksParser<false> pparser{cmd};
+    if(!pparser.validate(this->ref(), 0))
+        return pparser.build_command_result();
 
-    bool conOnError = cmd[0].has("continueonerror");
-    bool checkTp = false;
-    auto sgroupUpdate = false;
-    for (int index = 0; index < cmd.bulkCount(); index++) {
-        PARSE_PERMISSION(cmd);
+    bool update_clients{false}, update_server_group_list{false};
+    for(const auto& ppermission : pparser.iterate_valid_permissions()) {
+        for(const auto& serverGroup : groups)
+            ppermission.apply_to(serverGroup->permissions(), permission::v2::PermissionUpdateType::delete_value);
 
-        if(!ignore_granted_values && !permission::v2::permission_granted(0, this->calculate_permission(permType, 0, true))) {
-            if(conOnError) continue;
-            return command_result{permission::i_permission_modify_power};
-        }
-
-        for(const auto& serverGroup : groups) {
-            if (grant) {
-                serverGroup->permissions()->set_permission(permType, permission::v2::empty_permission_values, permission::v2::PermissionUpdateType::do_nothing, permission::v2::PermissionUpdateType::delete_value);
-            } else {
-                serverGroup->permissions()->set_permission(
-                        permType,
-                        permission::v2::empty_permission_values,
-                        permission::v2::PermissionUpdateType::delete_value,
-                        permission::v2::PermissionUpdateType::do_nothing
-                );
-                sgroupUpdate |= permission_is_group_property(permType);
-            }
-        }
-        checkTp |= permission_is_client_property(permType);
+        update_server_group_list |= ppermission.is_group_property();
+        update_clients |= ppermission.is_client_view_property();
     }
 
-
-    if(sgroupUpdate) {
+    if(update_server_group_list) {
         for(auto& group : groups)
             group->apply_properties_from_permissions();
     }
 
     if(ref_server) {
         auto lock = this->_this.lock();
-        threads::Thread([checkTp, sgroupUpdate, groups, lock, ref_server]() {
-            if(sgroupUpdate)
+        threads::Thread([update_clients, update_server_group_list, groups, lock, ref_server]() {
+            if(update_server_group_list)
                 ref_server->forEachClient([](shared_ptr<ConnectedClient> cl) {
                     cl->notifyServerGroupList();
                 });
-            ref_server->forEachClient([groups, checkTp](shared_ptr<ConnectedClient> cl) {
+            ref_server->forEachClient([groups, update_clients](shared_ptr<ConnectedClient> cl) {
                 for(const auto& serverGroup : groups) {
                     if (cl->serverGroupAssigned(serverGroup)) {
                         if(cl->update_cached_permissions()) /* update cached calculated permissions */
                             cl->sendNeededPermissions(false); /* cached permissions had changed, notify the client */
-                        if (checkTp)
+                        if (update_clients)
                             cl->updateChannelClientProperties(true, true);
                         cl->join_state_id++; /* join permission may changed, all channels need to be recalculate dif needed */
                         break;
@@ -1120,7 +1023,7 @@ command_result ConnectedClient::handleCommandServerGroupAutoDelPerm(ts::Command&
         }).detach();
     }
 
-    return command_result{error::ok};
+    return pparser.build_command_result();
 }
 
 command_result ConnectedClient::handleCommandServerGroupsByClientId(Command &cmd) {

server/src/client/file/FileClient.cpp

@@ -1,5 +1,5 @@
 #include <algorithm>
-#include <src/server/file/FileServer.h>
+#include <src/server/file/LocalFileServer.h>
 #include <log/LogUtils.h>
 #include "FileClient.h"
 #include <src/InstanceHandler.h>
@@ -15,7 +15,7 @@ using namespace ts::server;
 namespace fs = std::experimental::filesystem;
 
 #define BUFFER_SIZE (size_t) 2048
-FileClient::FileClient(FileServer* handle, int socketFd) : handle(handle), clientFd(socketFd) {
+FileClient::FileClient(LocalFileServer* handle, int socketFd) : handle(handle), clientFd(socketFd) {
     memtrack::allocated<FileClient>(this);
     this->last_io_action = system_clock::now();
 

server/src/client/file/FileClient.h

@@ -3,7 +3,7 @@
 #include <protocol/buffers.h>
 #include <poll.h>
 #include <fstream>
-#include <src/server/file/FileServer.h>
+#include <src/server/file/LocalFileServer.h>
 #include <event.h>
 #include <pipes/ws.h>
 #include <pipes/ssl.h>
@@ -14,7 +14,7 @@ namespace ts {
         class ConnectedClient;
 
         class ConnectedClient;
-        class FileServer;
+        class LocalFileServer;
 
         enum FTType {
                 Unknown,
@@ -28,7 +28,7 @@ namespace ts {
         };
 
         class FileClient {
-                friend class FileServer;
+                friend class LocalFileServer;
             public:
                 enum TransferState {
                     T_INITIALIZE,
@@ -45,7 +45,7 @@ namespace ts {
                     uint16_t length = 0;
                 };
 
-                FileClient(FileServer* handle, int socketFd);
+                FileClient(LocalFileServer* handle, int socketFd);
                 ~FileClient();
 
                 void disconnect(std::chrono::milliseconds = std::chrono::milliseconds(5000));
@@ -83,7 +83,7 @@ namespace ts {
                 void handle_ws_message(const pipes::WSMessage&);
                 bool handle_ts_message();
             private:
-                FileServer* handle;
+                LocalFileServer* handle;
                 std::weak_ptr<FileClient> _this;
 
                 std::recursive_mutex bandwidth_lock;

server/src/client/file/FileClientIO.cpp

@@ -1,6 +1,6 @@
 #include <algorithm>
 #include <memory>
-#include <src/server/file/FileServer.h>
+#include <src/server/file/LocalFileServer.h>
 #include <log/LogUtils.h>
 #include <misc/std_unique_ptr.h>
 #include <pipes/buffer.h>

server/src/client/music/internal_provider/channel_replay/ChannelProvider.cpp

@@ -1,7 +1,7 @@
 #include "ChannelProvider.h"
 #include "../../MusicClient.h"
 #include "../../../../InstanceHandler.h"
-#include "../../../../server/file/FileServer.h"
+#include "src/server/file/LocalFileServer.h"
 #include "../../../../../../music/providers/ffmpeg/FFMpegProvider.h"
 
 

server/src/client/query/QueryClient.cpp

@@ -77,7 +77,7 @@ void QueryClient::postInitialize() {
     if(ts::config::query::sslMode == 1 && this->connectionType != ConnectionType::SSL_ENCRIPTED) {
         command_result error{error::failed_connection_initialisation,  "Please use a SSL encryption!"};
         this->notifyError(error);
-        error.release_details();
+        error.release_data();
         this->disconnect("Please us a SSL encryption for more security.\nThe server denies also all other connections!");
         return;
     }
@@ -501,25 +501,25 @@ bool QueryClient::handleMessage(const pipes::buffer_view& message) {
         cmd = make_unique<Command>(Command::parse(pipes::buffer_view{(void*) command.data(), command.length()}, true, !ts::config::server::strict_ut8_mode));
     } catch(std::invalid_argument& ex) {
         logTrace(LOG_QUERY, "[{}:{}] Failed to parse command (invalid argument): {}", this->getLoggingPeerIp(), this->getPeerPort(), command);
-        error = command_result{error::parameter_convert};
+        error.reset(command_result{error::parameter_convert});
         goto handle_error;
     } catch(std::exception& ex) {
         logTrace(LOG_QUERY, "[{}:{}] Failed to parse command (exception: {}): {}", this->getLoggingPeerIp(), this->getPeerPort(), ex.what(), command);
-        error = command_result{error::vs_critical, std::string{ex.what()}};
+        error.reset(command_result{error::vs_critical, std::string{ex.what()}});
         goto handle_error;
     }
 
     try {
         this->handleCommandFull(*cmd);
     } catch(std::exception& ex) {
-        error = command_result{error::vs_critical, std::string{ex.what()}};
+        error.reset(command_result{error::vs_critical, std::string{ex.what()}});
         goto handle_error;
     }
     return true;
 
     handle_error:
     this->notifyError(error);
-    error.release_details();
+    error.release_data();
     return false;
 }
 

server/src/client/query/QueryClient.h

@@ -99,7 +99,7 @@ namespace ts::server {
             bool notifyServerUpdated(std::shared_ptr<ConnectedClient> ptr) override;
             bool notifyClientPoke(std::shared_ptr<ConnectedClient> invoker, std::string msg) override;
 
-            bool notifyClientUpdated(const std::shared_ptr<ConnectedClient> &ptr, const std::deque<std::shared_ptr<property::PropertyDescription>> &deque, bool lock_channel_tree) override;
+            bool notifyClientUpdated(const std::shared_ptr<ConnectedClient> &ptr, const std::deque<const property::PropertyDescription*> &deque, bool lock_channel_tree) override;
 
             bool notifyPluginCmd(std::string name, std::string msg,std::shared_ptr<ConnectedClient>) override;
             bool notifyClientChatComposing(const std::shared_ptr<ConnectedClient> &ptr) override;
@@ -171,6 +171,7 @@ namespace ts::server {
             command_result handleCommandServerIdGetByPort(Command&);
 
             command_result handleCommandServerSnapshotDeploy(Command&);
+            command_result handleCommandServerSnapshotDeployNew(const command_parser&);
             command_result handleCommandServerSnapshotCreate(Command&);
             command_result handleCommandServerProcessStop(Command&);
 

server/src/client/query/QueryClientCommands.cpp

@@ -10,6 +10,7 @@
 #include <misc/base64.h>
 #include <src/ShutdownHelper.h>
 #include <ThreadPool/Timer.h>
+#include <numeric>
 
 #include "src/client/command_handler/helpers.h"
 
@@ -99,9 +100,17 @@ command_result QueryClient::handleCommand(Command& cmd) {
             return this->handleCommandHostInfo(cmd);
         case string_hash("bindinglist"):
             return this->handleCommandBindingList(cmd);
-        case string_hash("serversnapshotdeploy"):
+        case string_hash("serversnapshotdeploy"): {
+#if 1
             return this->handleCommandServerSnapshotDeploy(cmd);
+#else
+            auto cmd_str = cmd.build();
+            ts::command_parser parser{cmd_str};
+            if(!parser.parse(true)) return command_result{error::vs_critical};
 
+            return this->handleCommandServerSnapshotDeployNew(parser);
+#endif
+        }
         case string_hash("serversnapshotcreate"):
             return this->handleCommandServerSnapshotCreate(cmd);
         case string_hash("serverprocessstop"):
@@ -165,8 +174,8 @@ command_result QueryClient::handleCommandLogin(Command& cmd) {
     if(!this->properties()[property::CLIENT_LOGIN_NAME].as<string>().empty()) {
         Command log("logout");
         auto result = this->handleCommandLogout(log);
-        if(result.error_code()) {
-            result.release_details();
+        if(result.has_error()) {
+            result.release_data();
             logError(this->getServerId(), "Query client failed to login from old login.");
             return command_result{error::vs_critical};
         }
@@ -303,7 +312,7 @@ command_result QueryClient::handleCommandServerSelect(Command &cmd) {
             target = serverInstance->getVoiceServerManager()->findServerById(static_cast<ServerId>(stol(parm)));
 
     if(!target && (!cmd[0].has("0") && (!cmd[0].has("sid") || !cmd["sid"] == 0))) return command_result{error::server_invalid_id, "Invalid server id"};
-    if(target && target->getState() != ServerState::ONLINE) return command_result{error::server_is_not_running};
+    if(target && target->getState() != ServerState::ONLINE && target->getState() != ServerState::OFFLINE) return command_result{error::server_is_not_running};
     if(target == this->server) return command_result{error::ok};
 
     if(target) {
@@ -397,37 +406,38 @@ command_result QueryClient::handleCommandServerInfo(Command &) {
 
 
     if(this->server && permission::v2::permission_granted(1, this->calculate_permission(permission::b_virtualserver_connectioninfo_view, 0))) {
-        auto stats = this->server->getServerStatistics()->statistics();
-        auto report = this->server->serverStatistics->dataReport();
-        cmd["connection_bandwidth_sent_last_second_total"] = report.send_second;
-        cmd["connection_bandwidth_sent_last_minute_total"] = report.send_minute;
-        cmd["connection_bandwidth_received_last_second_total"] = report.recv_second;
-        cmd["connection_bandwidth_received_last_minute_total"] = report.recv_minute;
+        auto total_stats = this->server->getServerStatistics()->total_stats();
+        auto report_second = this->server->serverStatistics->second_stats();
+        auto report_minute = this->server->serverStatistics->minute_stats();
+        cmd["connection_bandwidth_sent_last_second_total"] = std::accumulate(report_second.connection_bytes_sent.begin(), report_second.connection_bytes_sent.end(), (size_t) 0U);
+        cmd["connection_bandwidth_sent_last_minute_total"] = std::accumulate(report_minute.connection_bytes_sent.begin(), report_minute.connection_bytes_sent.end(), (size_t) 0U);
+        cmd["connection_bandwidth_received_last_second_total"] = std::accumulate(report_second.connection_bytes_received.begin(), report_second.connection_bytes_received.end(), (size_t) 0U);
+        cmd["connection_bandwidth_received_last_minute_total"] = std::accumulate(report_minute.connection_bytes_received.begin(), report_minute.connection_bytes_received.end(), (size_t) 0U);
 
-        cmd["connection_filetransfer_bandwidth_sent"] = report.file_send;
-        cmd["connection_filetransfer_bandwidth_received"] = report.file_recv;
-        cmd["connection_filetransfer_bytes_sent_total"] = (*stats)[property::CONNECTION_FILETRANSFER_BYTES_SENT_TOTAL].as<string>();
-        cmd["connection_filetransfer_bytes_received_total"] = (*stats)[property::CONNECTION_FILETRANSFER_BYTES_RECEIVED_TOTAL].as<string>();
+        cmd["connection_filetransfer_bandwidth_sent"] = report_minute.file_bytes_sent;
+        cmd["connection_filetransfer_bandwidth_received"] = report_minute.file_bytes_received;
+        cmd["connection_filetransfer_bytes_sent_total"] = total_stats.file_bytes_sent;
+        cmd["connection_filetransfer_bytes_received_total"] = total_stats.file_bytes_received;
 
-        cmd["connection_packets_sent_speech"] = (*stats)[property::CONNECTION_FILETRANSFER_BANDWIDTH_SENT].value();
-        cmd["connection_bytes_sent_speech"] = (*stats)[property::CONNECTION_FILETRANSFER_BANDWIDTH_RECEIVED].value();
-        cmd["connection_packets_received_speech"] = (*stats)[property::CONNECTION_FILETRANSFER_BYTES_SENT_TOTAL].value();
-        cmd["connection_bytes_received_speech"] = (*stats)[property::CONNECTION_FILETRANSFER_BYTES_RECEIVED_TOTAL].value();
+        cmd["connection_packets_sent_speech"] = total_stats.connection_packets_sent[stats::ConnectionStatistics::category::VOICE];
+        cmd["connection_bytes_sent_speech"] = total_stats.connection_bytes_sent[stats::ConnectionStatistics::category::VOICE];
+        cmd["connection_packets_received_speech"] = total_stats.connection_packets_received[stats::ConnectionStatistics::category::VOICE];
+        cmd["connection_bytes_received_speech"] = total_stats.connection_bytes_received[stats::ConnectionStatistics::category::VOICE];
 
-        cmd["connection_packets_sent_keepalive"] = (*stats)[property::CONNECTION_PACKETS_SENT_KEEPALIVE].value();
-        cmd["connection_packets_received_keepalive"] = (*stats)[property::CONNECTION_PACKETS_RECEIVED_KEEPALIVE].value();
-        cmd["connection_bytes_received_keepalive"] = (*stats)[property::CONNECTION_BYTES_RECEIVED_KEEPALIVE].value();
-        cmd["connection_bytes_sent_keepalive"] = (*stats)[property::CONNECTION_BYTES_SENT_KEEPALIVE].value();
+        cmd["connection_packets_sent_keepalive"] = total_stats.connection_packets_sent[stats::ConnectionStatistics::category::KEEP_ALIVE];
+        cmd["connection_packets_received_keepalive"] = total_stats.connection_bytes_sent[stats::ConnectionStatistics::category::KEEP_ALIVE];
+        cmd["connection_bytes_received_keepalive"] = total_stats.connection_packets_received[stats::ConnectionStatistics::category::KEEP_ALIVE];
+        cmd["connection_bytes_sent_keepalive"] = total_stats.connection_bytes_received[stats::ConnectionStatistics::category::KEEP_ALIVE];
 
-        cmd["connection_packets_sent_control"] = (*stats)[property::CONNECTION_PACKETS_SENT_CONTROL].value();
-        cmd["connection_bytes_sent_control"] = (*stats)[property::CONNECTION_BYTES_SENT_CONTROL].value();
-        cmd["connection_packets_received_control"] = (*stats)[property::CONNECTION_PACKETS_RECEIVED_CONTROL].value();
-        cmd["connection_bytes_received_control"] = (*stats)[property::CONNECTION_BYTES_RECEIVED_CONTROL].value();
+        cmd["connection_packets_sent_control"] = total_stats.connection_packets_sent[stats::ConnectionStatistics::category::COMMAND];
+        cmd["connection_bytes_sent_control"] = total_stats.connection_bytes_sent[stats::ConnectionStatistics::category::COMMAND];
+        cmd["connection_packets_received_control"] = total_stats.connection_packets_received[stats::ConnectionStatistics::category::COMMAND];
+        cmd["connection_bytes_received_control"] = total_stats.connection_bytes_received[stats::ConnectionStatistics::category::COMMAND];
 
-        cmd["connection_packets_sent_total"] = (*stats)[property::CONNECTION_PACKETS_SENT_TOTAL].value();
-        cmd["connection_bytes_sent_total"] = (*stats)[property::CONNECTION_BYTES_SENT_TOTAL].value();
-        cmd["connection_packets_received_total"] = (*stats)[property::CONNECTION_PACKETS_RECEIVED_TOTAL].value();
-        cmd["connection_bytes_received_total"] = (*stats)[property::CONNECTION_BYTES_RECEIVED_TOTAL].value();
+        cmd["connection_packets_sent_total"] = std::accumulate(total_stats.connection_packets_sent.begin(), total_stats.connection_packets_sent.end(), (size_t) 0U);
+        cmd["connection_bytes_sent_total"] = std::accumulate(total_stats.connection_bytes_sent.begin(), total_stats.connection_bytes_sent.end(), (size_t) 0U);
+        cmd["connection_packets_received_total"] = std::accumulate(total_stats.connection_packets_received.begin(), total_stats.connection_packets_received.end(), (size_t) 0U);
+        cmd["connection_bytes_received_total"] = std::accumulate(total_stats.connection_bytes_received.begin(), total_stats.connection_bytes_received.end(), (size_t) 0U);
     } else {
         cmd["connection_bandwidth_sent_last_second_total"] = "0";
         cmd["connection_bandwidth_sent_last_minute_total"] = "0";
@@ -476,11 +486,13 @@ command_result QueryClient::handleCommandChannelList(Command& cmd) {
     command_builder result{"", 1024, entries.size()};
     for(const auto& channel : entries){
         if(!channel) continue;
+
+        const auto channel_clients = this->server ? this->server->getClientsByChannel(channel).size() : 0;
         result.put_unchecked(index, "cid", channel->channelId());
         result.put_unchecked(index, "pid", channel->properties()[property::CHANNEL_PID].as<string>());
         result.put_unchecked(index, "channel_name", channel->name());
         result.put_unchecked(index, "channel_order", channel->channelOrder());
-        result.put_unchecked(index, "total_clients", this->server ? this->server->getClientsByChannel(channel).size() : 0);
+        result.put_unchecked(index, "total_clients", channel_clients);
         /* result.put_unchecked(index, "channel_needed_subscribe_power", channel->permissions()->getPermissionValue(permission::i_channel_needed_subscribe_power, channel, 0)); */
 
         if(cmd.hasParm("flags")){
@@ -512,8 +524,8 @@ command_result QueryClient::handleCommandChannelList(Command& cmd) {
         if(cmd.hasParm("topic")) {
             result.put_unchecked(index, "channel_topic", channel->properties()[property::CHANNEL_TOPIC].as<string>());
         }
-        if(cmd.hasParm("times")){
-            result.put_unchecked(index, "seconds_empty", channel->emptySince());
+        if(cmd.hasParm("times") || cmd.hasParm("secondsempty")){
+            result.put_unchecked(index, "seconds_empty", channel_clients == 0 ? channel->emptySince() : 0);
         }
         index++;
     }
@@ -582,9 +594,9 @@ command_result QueryClient::handleCommandServerCreate(Command& cmd) {
             time_wait = duration_cast<milliseconds>(end - start);
         }
 
-        uint16_t freePort = serverInstance->getVoiceServerManager()->next_available_port();
-
         std::string host = cmd[0].has("virtualserver_host") ? cmd["virtualserver_host"].as<string>() : config::binding::DefaultVoiceHost;
+        uint16_t freePort = serverInstance->getVoiceServerManager()->next_available_port(host);
+
         uint16_t port = cmd[0].has("virtualserver_port") ? cmd["virtualserver_port"].as<uint16_t>() : freePort;
         {
             auto _start = system_clock::now();
@@ -598,12 +610,12 @@ command_result QueryClient::handleCommandServerCreate(Command& cmd) {
             if(key == "virtualserver_port") continue;
             if(key == "virtualserver_host") continue;
 
-            auto info = property::impl::info<property::VirtualServerProperties>(key);
-            if(*info == property::VIRTUALSERVER_UNDEFINED) {
+            const auto& info = property::find<property::VirtualServerProperties>(key);
+            if(info == property::VIRTUALSERVER_UNDEFINED) {
                 logError(server->getServerId(), "Tried to change unknown server property " + key);
                 continue;
             }
-            if(!info->validate_input(cmd[key].as<string>())) {
+            if(!info.validate_input(cmd[key].as<string>())) {
                 logError(server->getServerId(), "Tried to change " + key + " to an invalid value: " + cmd[key].as<string>());
                 continue;
             }
@@ -722,9 +734,9 @@ command_result QueryClient::handleCommandInstanceEdit(Command& cmd) {
     ACTION_REQUIRES_INSTANCE_PERMISSION(permission::b_serverinstance_modify_settings, 1);
 
     for(const auto &key : cmd[0].keys()){
-        auto info = property::impl::info<property::InstanceProperties>(key);
+        const auto* info = &property::find<property::InstanceProperties>(key);
         if(key == "serverinstance_serverquery_max_connections_per_ip")
-            info = property::impl::info(property::SERVERINSTANCE_QUERY_MAX_CONNECTIONS_PER_IP);
+            info = &property::describe(property::SERVERINSTANCE_QUERY_MAX_CONNECTIONS_PER_IP);
 
         if(*info == property::SERVERINSTANCE_UNDEFINED) {
             logError(LOG_QUERY, "Query {} tried to change a non existing instance property: {}", this->getLoggingPeerIp(), key);
@@ -758,22 +770,24 @@ command_result QueryClient::handleCommandHostInfo(Command &) {
     res["virtualservers_total_channels_online"] = vsReport.onlineChannels;
 
 
-    auto stats = serverInstance->getStatistics()->statistics();
-    res["connection_packets_sent_total"] = (*stats)[property::CONNECTION_PACKETS_SENT_TOTAL].as<string>();
-    res["connection_bytes_sent_total"] = (*stats)[property::CONNECTION_BYTES_SENT_TOTAL].as<string>();
-    res["connection_packets_received_total"] = (*stats)[property::CONNECTION_PACKETS_RECEIVED_TOTAL].as<string>();
-    res["connection_bytes_received_total"] = (*stats)[property::CONNECTION_BYTES_RECEIVED_TOTAL].as<string>();
+    auto total_stats = serverInstance->getStatistics()->total_stats();
+    res["connection_packets_sent_total"] = std::accumulate(total_stats.connection_packets_sent.begin(), total_stats.connection_packets_sent.end(), (size_t) 0U);
+    res["connection_bytes_sent_total"] = std::accumulate(total_stats.connection_bytes_sent.begin(), total_stats.connection_bytes_sent.end(), (size_t) 0U);
+    res["connection_packets_received_total"] = std::accumulate(total_stats.connection_packets_received.begin(), total_stats.connection_packets_received.end(), (size_t) 0U);
+    res["connection_bytes_received_total"] = std::accumulate(total_stats.connection_bytes_received.begin(), total_stats.connection_bytes_received.end(), (size_t) 0U);
 
-    auto report = serverInstance->getStatistics()->dataReport();
-    res["connection_bandwidth_sent_last_second_total"] = report.send_second;
-    res["connection_bandwidth_sent_last_minute_total"] = report.send_minute;
-    res["connection_bandwidth_received_last_second_total"] = report.recv_second;
-    res["connection_bandwidth_received_last_minute_total"] = report.recv_minute;
+    auto report_second = serverInstance->getStatistics()->second_stats();
+    auto report_minute = serverInstance->getStatistics()->minute_stats();
+    res["connection_bandwidth_sent_last_second_total"] = std::accumulate(report_second.connection_bytes_sent.begin(), report_second.connection_bytes_sent.end(), (size_t) 0U);
+    res["connection_bandwidth_sent_last_minute_total"] = std::accumulate(report_minute.connection_bytes_sent.begin(), report_minute.connection_bytes_sent.end(), (size_t) 0U);
+    res["connection_bandwidth_received_last_second_total"] = std::accumulate(report_second.connection_bytes_received.begin(), report_second.connection_bytes_received.end(), (size_t) 0U);
+    res["connection_bandwidth_received_last_minute_total"] = std::accumulate(report_minute.connection_bytes_received.begin(), report_minute.connection_bytes_received.end(), (size_t) 0U);
 
-    res["connection_filetransfer_bandwidth_sent"] = report.file_send;
-    res["connection_filetransfer_bandwidth_received"] = report.file_recv;
-    res["connection_filetransfer_bytes_sent_total"] = (*stats)[property::CONNECTION_FILETRANSFER_BYTES_SENT_TOTAL].as<string>();
-    res["connection_filetransfer_bytes_received_total"] = (*stats)[property::CONNECTION_FILETRANSFER_BYTES_RECEIVED_TOTAL].as<string>();
+
+    res["connection_filetransfer_bandwidth_sent"] = report_minute.file_bytes_sent;
+    res["connection_filetransfer_bandwidth_received"] = report_minute.file_bytes_received;
+    res["connection_filetransfer_bytes_sent_total"] = total_stats.file_bytes_sent;
+    res["connection_filetransfer_bytes_received_total"] = total_stats.file_bytes_received;
 
     this->sendCommand(res);
     return command_result{error::ok};
@@ -837,7 +851,7 @@ command_result QueryClient::handleCommandServerSnapshotDeploy(Command& cmd) {
 
     unique_lock server_create_lock(serverInstance->getVoiceServerManager()->server_create_lock);
     if(port == 0)
-        port = serverInstance->getVoiceServerManager()->next_available_port();
+        port = serverInstance->getVoiceServerManager()->next_available_port(host);
     auto result = serverInstance->getVoiceServerManager()->createServerFromSnapshot(this->server, host, port, cmd, error);
     server_create_lock.unlock();
     auto end = system_clock::now();
@@ -867,6 +881,32 @@ command_result QueryClient::handleCommandServerSnapshotDeploy(Command& cmd) {
     return command_result{error::ok};
 }
 
+command_result QueryClient::handleCommandServerSnapshotDeployNew(const ts::command_parser &command) {
+    CMD_RESET_IDLE;
+
+    if(this->server) {
+        return command_result{error::not_implemented};
+        ACTION_REQUIRES_GLOBAL_PERMISSION(permission::b_virtualserver_snapshot_deploy, 1);
+        //host = this->server->properties()[property::VIRTUALSERVER_HOST].as<string>();
+        //port = this->server->properties()[property::VIRTUALSERVER_PORT].as<uint16_t>();
+    } else {
+        ACTION_REQUIRES_INSTANCE_PERMISSION(permission::b_virtualserver_snapshot_deploy, 1);
+    }
+
+    std::string error{};
+    unique_lock server_create_lock(serverInstance->getVoiceServerManager()->server_create_lock);
+    //TODO: Create a server if no exists
+    server_create_lock.unlock();
+
+    //TODO: Stop the server completely
+    if(!serverInstance->getVoiceServerManager()->deploy_snapshot(error, 111, command)) {
+        //TODO: Delete server is it was new
+        return command_result{error::vs_critical, error};
+    }
+
+    return command_result{error::ok};
+}
+
 command_result QueryClient::handleCommandServerSnapshotCreate(Command& cmd) {
     ACTION_REQUIRES_GLOBAL_PERMISSION(permission::b_virtualserver_snapshot_create, 1);
     CMD_RESET_IDLE;

server/src/client/query/QueryClientNotify.cpp

@@ -42,7 +42,7 @@ bool QueryClient::notifyServerUpdated(shared_ptr<ConnectedClient> ptr) {
     return ConnectedClient::notifyServerUpdated(ptr);
 }
 
-bool QueryClient::notifyClientUpdated(const std::shared_ptr<ConnectedClient> &ptr, const std::deque<std::shared_ptr<property::PropertyDescription>> &deque, bool lock_channel_tree) {
+bool QueryClient::notifyClientUpdated(const std::shared_ptr<ConnectedClient> &ptr, const std::deque<const property::PropertyDescription*> &deque, bool lock_channel_tree) {
     CHK_EVENT(QEVENTGROUP_CLIENT_MISC, QEVENTSPECIFIER_CLIENT_MISC_UPDATE);
     return ConnectedClient::notifyClientUpdated(ptr, deque, lock_channel_tree);
 }

server/src/client/voice/PacketStatistics.cpp

@@ -0,0 +1,123 @@
+//
+// Created by WolverinDEV on 06/04/2020.
+//
+
+#include "PacketStatistics.h"
+
+using namespace ts::server::client;
+
+void PacketStatistics::received_packet(ts::protocol::PacketType type, uint32_t pid) {
+    std::lock_guard lock{this->data_mutex};
+    switch (type) {
+        case protocol::PacketType::VOICE:
+            this->calculator_voice.packet_received(pid);
+            return;
+        case protocol::PacketType::VOICE_WHISPER:
+            this->calculator_voice_whisper.packet_received(pid);
+            return;
+
+        case protocol::PacketType::COMMAND:
+        case protocol::PacketType::COMMAND_LOW:
+            return;
+
+        case protocol::PacketType::ACK:
+            this->calculator_ack.packet_received(pid);
+            return;
+        case protocol::PacketType::ACK_LOW:
+            this->calculator_ack_low.packet_received(pid);
+            return;
+        case protocol::PacketType::PING:
+            this->calculator_ping.packet_received(pid);
+            return;
+
+        default:
+            /* some invalid packet lul */
+            return;
+    }
+}
+
+void PacketStatistics::send_command(ts::protocol::PacketType type, uint32_t pid) {
+    std::lock_guard lock{this->data_mutex};
+    if(type == protocol::PacketType::COMMAND)
+        this->calculator_command.packet_send(pid);
+    else if(type == protocol::PacketType::COMMAND_LOW)
+        this->calculator_command_low.packet_send(pid);
+}
+
+void PacketStatistics::received_acknowledge(ts::protocol::PacketType type, uint32_t pid) {
+    std::lock_guard lock{this->data_mutex};
+    if(type == protocol::PacketType::ACK)
+        this->calculator_command.ack_received(pid);
+    else if(type == protocol::PacketType::ACK_LOW)
+        this->calculator_command_low.ack_received(pid);
+}
+
+PacketStatistics::PacketLossReport PacketStatistics::loss_report() const {
+    PacketStatistics::PacketLossReport result{};
+
+    result.received_voice = this->calculator_voice.received_packets() +  this->calculator_voice_whisper.received_packets();
+    result.lost_voice = this->calculator_voice.lost_packets() +  this->calculator_voice_whisper.lost_packets();
+
+    result.received_keep_alive = this->calculator_ping.received_packets();
+    result.lost_keep_alive = this->calculator_ping.lost_packets();
+
+    result.received_control = this->calculator_command.received_packets() + this->calculator_command_low.received_packets();
+    result.lost_control = this->calculator_command.lost_packets() + this->calculator_command_low.lost_packets();
+    //result.lost_control -= this->calculator_ack.lost_packets() + this->calculator_ack_low.lost_packets(); /* subtract the lost acks (command received but ack got lost) */
+
+    result.received_control += this->calculator_ack.received_packets() + this->calculator_ack_low.received_packets();
+    //result.lost_control += this->calculator_ack.lost_packets() + this->calculator_ack_low.lost_packets(); /* this cancels out the line above */
+    return result;
+}
+
+void PacketStatistics::tick() {
+    auto now = std::chrono::system_clock::now();
+    if(now + std::chrono::seconds{15} > this->last_short) {
+        this->last_short = now;
+
+        std::lock_guard lock{this->data_mutex};
+        this->calculator_command.short_stats();
+        this->calculator_command_low.short_stats();
+
+        this->calculator_ack.short_stats();
+        this->calculator_ack_low.short_stats();
+
+        this->calculator_voice.short_stats();
+        this->calculator_voice_whisper.short_stats();
+
+        this->calculator_ping.short_stats();
+    }
+}
+
+void PacketStatistics::reset() {
+    std::lock_guard lock{this->data_mutex};
+    this->calculator_command.reset();
+    this->calculator_command_low.reset();
+
+    this->calculator_ack.reset();
+    this->calculator_ack_low.reset();
+
+    this->calculator_voice.reset();
+    this->calculator_voice_whisper.reset();
+
+    this->calculator_ping.reset();
+}
+
+void PacketStatistics::reset_offsets() {
+    std::lock_guard lock{this->data_mutex};
+    this->calculator_command.reset_offsets();
+    this->calculator_command_low.reset_offsets();
+
+    this->calculator_ack.reset_offsets();
+    this->calculator_ack_low.reset_offsets();
+
+    this->calculator_voice.reset_offsets();
+    this->calculator_voice_whisper.reset_offsets();
+
+    this->calculator_ping.reset_offsets();
+}
+
+float PacketStatistics::current_packet_loss() const {
+    auto report = this->loss_report();
+    return report.total_loss();
+}

server/src/client/voice/PacketStatistics.h

@@ -0,0 +1,68 @@
+#pragma once
+
+#include <protocol/PacketLossCalculator.h>
+#include <protocol/Packet.h>
+#include <misc/spin_mutex.h>
+
+namespace ts::server::client {
+    class PacketStatistics {
+        public:
+            struct PacketLossReport {
+                uint32_t lost_voice{0};
+                uint32_t lost_control{0};
+                uint32_t lost_keep_alive{0};
+
+                uint32_t received_voice{0};
+                uint32_t received_control{0};
+                uint32_t received_keep_alive{0};
+
+                [[nodiscard]] inline float voice_loss() const {
+                    const auto total_packets = this->received_voice + this->lost_voice;
+                    if(total_packets == 0) return 0;
+                    return this->lost_voice / (float) total_packets;
+                }
+                [[nodiscard]] inline float control_loss() const {
+                    const auto total_packets = this->received_control + this->lost_control;
+                    //if(total_packets == 0) return 0; /* not possible so remove this to speed it up */
+                    return this->lost_control / (float) total_packets;
+                }
+                [[nodiscard]] inline float keep_alive_loss() const {
+                    const auto total_packets = this->received_keep_alive + this->lost_keep_alive;
+                    if(total_packets == 0) return 0;
+                    return this->lost_keep_alive / (float) total_packets;
+                }
+
+                [[nodiscard]] inline float total_loss() const {
+                    const auto total_lost = this->lost_voice + this->lost_control + this->lost_keep_alive;
+                    const auto total_received = this->received_control + this->received_voice + this->received_keep_alive;
+                    //if(total_received + total_lost == 0) return 0; /* not possible to speed this up */
+                    return total_lost / (float) (total_lost + total_received);
+                }
+            };
+
+            [[nodiscard]] PacketLossReport loss_report() const;
+            [[nodiscard]] float current_packet_loss() const;
+
+            void send_command(protocol::PacketType /* type */, uint32_t /* packet id */);
+            void received_acknowledge(protocol::PacketType /* type */, uint32_t /* packet id */);
+
+            void received_packet(protocol::PacketType /* type */, uint32_t /* packet id */);
+            void tick();
+            void reset();
+            void reset_offsets();
+        private:
+            std::chrono::system_clock::time_point last_short{};
+
+            spin_mutex data_mutex{};
+            protocol::UnorderedPacketLossCalculator calculator_voice_whisper{};
+            protocol::UnorderedPacketLossCalculator calculator_voice{};
+
+            protocol::UnorderedPacketLossCalculator calculator_ack_low{};
+            protocol::UnorderedPacketLossCalculator calculator_ack{};
+
+            protocol::UnorderedPacketLossCalculator calculator_ping{};
+
+            protocol::CommandPacketLossCalculator calculator_command{};
+            protocol::CommandPacketLossCalculator calculator_command_low{};
+    };
+}

server/src/client/voice/PrecomputedPuzzles.cpp

@@ -1,50 +1,63 @@
-#include "PrecomputedPuzzles.h"
-#include "../../Configuration.h"
-#include "../ConnectedClient.h"
+#include "./PrecomputedPuzzles.h"
+#include "src/Configuration.h"
 #include <tomcrypt.h>
 
 using namespace std;
-using namespace ts;
-using namespace ts::protocol;
+using namespace ts::server::udp;
 
-PuzzleManager::PuzzleManager() {}
-PuzzleManager::~PuzzleManager() {}
+PuzzleManager::PuzzleManager() = default;
+PuzzleManager::~PuzzleManager() = default;
 
-size_t PuzzleManager::precomputedPuzzleCount() { return this->cached.size(); }
-
-bool PuzzleManager::precomputePuzzles(size_t limit) {
-    while(precomputedPuzzleCount() < limit) generatePuzzle();
-    return true;
+size_t PuzzleManager::precomputed_puzzle_count() {
+    std::lock_guard lock{this->cache_lock};
+    return this->cached_puzzles.size();
 }
 
-std::shared_ptr<Puzzle> PuzzleManager::nextPuzzle() {
-    this->indexLock.lock();
-    size_t index = this->cacheIndex++ % this->cached.size();
-    this->indexLock.unlock();
-    return this->cached[index];
+bool PuzzleManager::precompute_puzzles(size_t amount) {
+    std::random_device rd{};
+    std::mt19937 mt{rd()};
+
+    amount = 5;
+    while(this->precomputed_puzzle_count() < amount)
+        this->generate_puzzle(mt);
+    return this->precomputed_puzzle_count() > 0;
 }
 
-inline void rndNum(mp_int *result, int byteLength){
-    uint8_t buffer[byteLength];
-
-    for(int index = 0; index < byteLength; index++) {
-        int rnd = rand();
-        uint8_t urnd = static_cast<uint8_t>(rnd & 0xFF);
-        buffer[index] = urnd; //TODO more secure!
-
+std::shared_ptr<Puzzle> PuzzleManager::next_puzzle() {
+    {
+        std::lock_guard lock{this->cache_lock};
+        auto it = this->cached_puzzles.begin() + (this->cache_index++ % this->cached_puzzles.size());
+        if((*it)->fail_count > 2) {
+            this->cached_puzzles.erase(it);
+        } else {
+            return *it;
+        }
     }
 
-    mp_zero(result);
-    mp_read_unsigned_bin(result, buffer, byteLength);
+    std::random_device rd{};
+    std::mt19937 mt{rd()};
+    this->generate_puzzle(mt);
+    return this->next_puzzle();
 }
 
-inline bool solvePuzzle(Puzzle *puzzle){
+inline void random_number(std::mt19937& generator, mp_int *result, int length){
+    std::uniform_int_distribution<uint8_t> dist{};
+
+    uint8_t buffer[length];
+    for(auto& byte : buffer)
+        byte = dist(generator);
+
+    mp_zero(result);
+    mp_read_unsigned_bin(result, buffer, length);
+}
+
+inline bool solve_puzzle(Puzzle *puzzle) {
     mp_int exp{};
     mp_init(&exp);
     mp_2expt(&exp, puzzle->level);
 
 
-    if (mp_exptmod(&puzzle->x, &exp, &puzzle->n, &puzzle->result) != CRYPT_OK) { //Sometimes it fails (unknow why :D)
+    if (mp_exptmod(&puzzle->x, &exp, &puzzle->n, &puzzle->result) != CRYPT_OK) { //Sometimes it fails (unknown why :D)
         mp_clear(&exp);
         return false;
     }
@@ -66,17 +79,27 @@ inline bool write_bin_data(mp_int& data, uint8_t* result, size_t length) {
     return true;
 }
 
-void PuzzleManager::generatePuzzle() {
+void PuzzleManager::generate_puzzle(std::mt19937& random_generator) {
     auto puzzle = new Puzzle{};
 
+    puzzle->level = ts::config::voice::RsaPuzzleLevel;
     mp_init_multi(&puzzle->x, &puzzle->n, &puzzle->result, nullptr);
 
     generate_new:
-    rndNum(&puzzle->x, 64);
-    rndNum(&puzzle->n, 64);
-    puzzle->level = ts::config::voice::RsaPuzzleLevel;
+    static int x{0};
+    if(x++ == 0 || true) {
+        mp_set(&puzzle->x, 1);
+        mp_set(&puzzle->n, 1);
+        //random_number(random_generator, &puzzle->x, 64);
+        //random_number(random_generator, &puzzle->n, 64);
+    } else {
+        const static std::string_view n_{"\x01\x7a\xc5\x8d\x28\x7a\x61\x58\xf6\xe3\x98\x60\x2f\x81\x9c\x8a\x48\xc9\x20\xd1\x59\xe0\x24\x75\x91\x27\x9f\x52\x1e\x2c\x24\x85\xa9\xdc\x74\xfa\x0b\x36\xf9\x6c\x77\xa3\x7c\xf9\xbb\xf7\x04\xad\xa3\x84\x0d\x97\x25\x54\x19\x72\x4f\x8f\xfc\x66\xbe\x41\xda\x95"};
+        const static std::string_view x_{"\xd1\xef\xf0\x16\x34\x48\x56\x53\x15\x97\xa0\x28\xbd\x13\xce\xbf\xc2\xd6\x79\x9d\x21\x81\x83\x37\x8c\xe8\xee\xee\xa1\x22\xa4\xf5\x63\x33\x53\x0c\x38\x2f\x0a\x00\x53\x20\xc7\x93\x52\xa9\xd0\xc2\xfb\xbc\xc5\xc4\xc3\x54\xad\xcb\x49\x52\xc0\xd8\x97\x32\x94\xee"};
+        mp_read_unsigned_bin(&puzzle->x, (unsigned char*) x_.data(), x_.length());
+        mp_read_unsigned_bin(&puzzle->n, (unsigned char*) n_.data(), n_.length());
+    }
 
-    if(!solvePuzzle(puzzle))
+    if(!solve_puzzle(puzzle))
         goto generate_new;
 
     auto valid_x = mp_unsigned_bin_size(&puzzle->x) <= 64;
@@ -94,7 +117,7 @@ void PuzzleManager::generatePuzzle() {
     if(!write_bin_data(puzzle->result, puzzle->data_result, 64))
         goto generate_new;
 
-    this->cached.push_back(shared_ptr<Puzzle>(puzzle, [](Puzzle* elm){
+    this->cached_puzzles.push_back(shared_ptr<Puzzle>(puzzle, [](Puzzle* elm){
         mp_clear_multi(&elm->n, &elm->x, &elm->result, nullptr);
         delete elm;
     }));

server/src/client/voice/PrecomputedPuzzles.h

@@ -1,44 +1,41 @@
 #pragma once
 
-#include <ThreadPool/Mutex.h>
 #include <tommath.h>
 #include <memory>
-#include <deque>
+#include <vector>
+#include <misc/spin_mutex.h>
+#include <random>
 
-namespace ts {
-    namespace server {
-        class ConnectedClient;
-    }
+namespace ts::server::udp {
+    struct Puzzle {
+        mp_int x{};
+        mp_int n{};
+        int level{0};
 
-    namespace protocol {
-        struct Puzzle {
-            mp_int x;
-            mp_int n;
-            int level;
+        mp_int result{};
 
-            mp_int result;
+        uint8_t data_x[64]{0};
+        uint8_t data_n[64]{0};
+        uint8_t data_result[64]{0};
 
-            uint8_t data_x[64];
-            uint8_t data_n[64];
-            uint8_t data_result[64];
-        };
-        class PuzzleManager {
-            public:
-                PuzzleManager();
-                ~PuzzleManager();
+        size_t fail_count{0};
+    };
 
-                bool precomputePuzzles(size_t limit);
+    class PuzzleManager {
+        public:
+            PuzzleManager();
+            ~PuzzleManager();
 
-                size_t precomputedPuzzleCount();
+            [[nodiscard]] bool precompute_puzzles(size_t amount);
 
-                std::shared_ptr<Puzzle> nextPuzzle();
-            private:
-                void generatePuzzle();
+            [[nodiscard]] size_t precomputed_puzzle_count();
 
-                threads::Mutex indexLock;
-                size_t cacheIndex = 0;
+            [[nodiscard]] std::shared_ptr<Puzzle> next_puzzle();
+        private:
+            void generate_puzzle(std::mt19937&);
 
-                std::deque<std::shared_ptr<Puzzle>> cached;
-        };
-    }
+            size_t cache_index{0};
+            spin_mutex cache_lock{};
+            std::vector<std::shared_ptr<Puzzle>> cached_puzzles{};
+    };
 }