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

@@ -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/server/DatabaseHandler.cpp

@@ -533,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/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/WebAPI.cpp

@@ -297,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;
@@ -334,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
@@ -353,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;

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

@@ -49,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
@@ -61,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
@@ -81,7 +83,6 @@ set(SERVER_SOURCE_FILES
         src/client/query/QueryClientCommands.cpp
         src/client/query/QueryClientNotify.cpp
 
-
         src/manager/IpListManager.cpp
 
         src/ConnectionStatistics.cpp
@@ -136,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)
@@ -235,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 "")
@@ -281,7 +289,13 @@ 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/)
@@ -307,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"
@@ -50,8 +50,8 @@ 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) {
@@ -573,27 +574,66 @@ bool ConnectedClient::notifyClientNeededPermissions() {
     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;
 }
 
@@ -635,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);
 }
@@ -744,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;
 
@@ -784,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) {
@@ -800,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());
@@ -815,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)");
@@ -823,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();
@@ -832,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)
@@ -846,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};
         }
@@ -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{};
+    };
 }

server/src/client/voice/VoiceClient.cpp

@@ -47,21 +47,8 @@ VoiceClient::~VoiceClient() {
     memtrack::freed<VoiceClient>(this);
 }
 
-void VoiceClient::sendCommand0(const std::string_view& cmd, bool low, bool direct, std::unique_ptr<threads::Future<bool>> listener) {
-    if(cmd.empty()) {
-        logCritical(this->getServerId(), "{} Attempted to send an empty command!", CLIENT_STR_LOG_PREFIX);
-        return;
-    }
-
-    auto packet = make_shared<protocol::ServerPacket>(
-            low ? protocol::PacketTypeInfo::CommandLow : protocol::PacketTypeInfo::Command,
-            pipes::buffer_view{(void*) cmd.data(), cmd.length()}
-    );
-    if(low) {
-        packet->enable_flag(protocol::PacketFlag::NewProtocol);
-    }
-    packet->setListener(std::move(listener));
-    this->connection->sendPacket(packet, false, direct);
+void VoiceClient::sendCommand0(const std::string_view& cmd, bool low, std::unique_ptr<threads::Future<bool>> listener) {
+    this->connection->send_command(cmd, low, std::move(listener));
 
 #ifdef PKT_LOG_CMD
     logTrace(this->getServerId(), "{}[Command][Server -> Client] Sending command {}. Command low: {}. Full command: {}", CLIENT_STR_LOG_PREFIX, cmd.substr(0, cmd.find(' ')), low, cmd);
@@ -71,10 +58,8 @@ void VoiceClient::sendAcknowledge(uint16_t packetId, bool low) {
     char buffer[2];
     le2be16(packetId, buffer);
 
-    auto packet = make_shared<protocol::ServerPacket>(low ? protocol::PacketTypeInfo::AckLow : protocol::PacketTypeInfo::Ack, pipes::buffer_view{buffer, 2});
-    packet->enable_flag(PacketFlag::Unencrypted);
-    if(!low) packet->enable_flag(protocol::PacketFlag::NewProtocol);
-    this->connection->sendPacket(packet);
+    auto pflags = PacketFlag::Unencrypted | PacketFlag::NewProtocol;
+    this->connection->send_packet(low ? protocol::PacketType::ACK_LOW : protocol::PacketType::ACK, (PacketFlag::PacketFlag) pflags, buffer, 2);
 #ifdef PKT_LOG_ACK
     logTrace(this->getServerId(), "{}[Acknowledge][Server -> Client] Sending acknowledge for {}", CLIENT_STR_LOG_PREFIX, packetId);
 #endif
@@ -108,6 +93,8 @@ void VoiceClient::tick(const std::chrono::system_clock::time_point &time) {
                 } else
                     this->sendPingRequest();
             }
+
+            this->connection->packet_statistics().tick();
         } else if(this->state == ConnectionState::INIT_LOW || this->state == ConnectionState::INIT_HIGH) {
             if(this->last_packet_handshake.time_since_epoch().count() != 0) {
                 if(time - this->last_packet_handshake > seconds(5)) {
@@ -184,7 +171,7 @@ bool VoiceClient::disconnect(ts::ViewReasonId reason_id, const std::string &reas
 
             self->close_connection(chrono::system_clock::time_point{}); /* we received the ack, we do not need to flush anything */
         }, system_clock::now() + seconds(5));
-        this->sendCommand0(cmd.build(), false, false, std::move(listener));
+        this->sendCommand0(cmd.build(), false, std::move(listener));
     } else {
         //TODO: Extra case for INIT_HIGH?
         this->close_connection(chrono::system_clock::now() + chrono::seconds{5});
@@ -282,31 +269,29 @@ void VoiceClient::execute_handle_packet(const std::chrono::system_clock::time_po
 }
 
 void VoiceClient::send_voice_packet(const pipes::buffer_view &voice_buffer, const SpeakingClient::VoicePacketFlags &flags) {
-    auto packet = make_shared<ServerPacket>(PacketTypeInfo::Voice, voice_buffer.length());
-    {
-        PacketFlag::PacketFlags packet_flags = PacketFlag::None;
-        packet_flags |= flags.encrypted ? 0 : PacketFlag::Unencrypted;
-        packet_flags |= flags.head ? PacketFlag::Compressed : 0;
-        packet_flags |= flags.fragmented ? PacketFlag::Fragmented : 0;
-        packet_flags |= flags.new_protocol ? PacketFlag::NewProtocol : 0;
-        packet->set_flags(packet_flags);
-    }
+    PacketFlag::PacketFlags packet_flags{PacketFlag::None};
+    packet_flags |= flags.encrypted ? 0U : PacketFlag::Unencrypted;
+    packet_flags |= flags.head ? PacketFlag::Compressed : 0U;
+    packet_flags |= flags.fragmented ? PacketFlag::Fragmented : 0U;
+    packet_flags |= flags.new_protocol ? PacketFlag::NewProtocol : 0U;
 
-    memcpy(packet->data().data_ptr<void>(), voice_buffer.data_ptr<void>(), voice_buffer.length());
-    this->connection->sendPacket(packet, false, false);
+    this->connection->send_packet(PacketType::VOICE, packet_flags, voice_buffer.data_ptr<void>(), voice_buffer.length());
 }
 
 void VoiceClient::send_voice_whisper_packet(const pipes::buffer_view &voice_buffer, const SpeakingClient::VoicePacketFlags &flags) {
-    auto packet = make_shared<ServerPacket>(PacketTypeInfo::VoiceWhisper, voice_buffer.length());
-    {
-        PacketFlag::PacketFlags packet_flags = PacketFlag::None;
-        packet_flags |= flags.encrypted ? 0 : PacketFlag::Unencrypted;
-        packet_flags |= flags.head ? PacketFlag::Compressed : 0;
-        packet_flags |= flags.fragmented ? PacketFlag::Fragmented : 0;
-        packet_flags |= flags.new_protocol ? PacketFlag::NewProtocol : 0;
-        packet->set_flags(packet_flags);
-    }
+    PacketFlag::PacketFlags packet_flags{PacketFlag::None};
+    packet_flags |= flags.encrypted ? 0U : PacketFlag::Unencrypted;
+    packet_flags |= flags.head ? PacketFlag::Compressed : 0U;
+    packet_flags |= flags.fragmented ? PacketFlag::Fragmented : 0U;
+    packet_flags |= flags.new_protocol ? PacketFlag::NewProtocol : 0U;
 
-    memcpy(packet->data().data_ptr<void>(), voice_buffer.data_ptr<void>(), voice_buffer.length());
-    this->connection->sendPacket(packet, false, false);
+    this->connection->send_packet(PacketType::VOICE_WHISPER, packet_flags, voice_buffer.data_ptr<void>(), voice_buffer.length());
+}
+
+float VoiceClient::current_ping_deviation() {
+    return this->connection->getAcknowledgeManager().current_rttvar();
+}
+
+float VoiceClient::current_packet_loss() const {
+    return this->connection->packet_statistics().current_packet_loss();
 }

server/src/client/voice/VoiceClient.h

@@ -58,12 +58,16 @@ namespace ts {
                 virtual void sendCommand(const ts::command_builder &command, bool low) { return this->sendCommand0(command.build(), low); }
 
                 /* Note: Order is only guaranteed if progressDirectly is on! */
-                virtual void sendCommand0(const std::string_view& /* data */, bool low = false, bool progressDirectly = false, std::unique_ptr<threads::Future<bool>> listener = nullptr);
+                virtual void sendCommand0(const std::string_view& /* data */, bool low = false, std::unique_ptr<threads::Future<bool>> listener = nullptr);
                 virtual void sendAcknowledge(uint16_t packetId, bool low = false);
 
                 connection::VoiceClientConnection* getConnection(){ return connection; }
                 std::shared_ptr<VoiceServer> getVoiceServer(){ return voice_server; }
-                std::chrono::milliseconds calculatePing(){ return ping; }
+
+                [[nodiscard]] inline std::chrono::milliseconds current_ping(){ return ping; }
+                [[nodiscard]] float current_ping_deviation();
+
+                [[nodiscard]] float current_packet_loss() const;
             private:
                 connection::VoiceClientConnection* connection;
 
@@ -76,6 +80,7 @@ namespace ts {
                 void handlePacketCommand(const pipes::buffer_view&);
                 void handlePacketAck(const protocol::ClientPacketParser&);
                 void handlePacketVoice(const protocol::ClientPacketParser&);
+                void handlePacketVoiceWhisper(const protocol::ClientPacketParser&);
                 void handlePacketPing(const protocol::ClientPacketParser&);
                 void handlePacketInit(const protocol::ClientPacketParser&);
 
@@ -120,6 +125,7 @@ namespace ts {
                     bool client_init = false;
                     bool new_protocol = false;
                     bool protocol_encrypted = false;
+                    bool is_teaspeak_client = false;
 
                     uint32_t client_time = 0;
                     std::string alpha;

server/src/client/voice/VoiceClientConnection.cpp

@@ -32,23 +32,16 @@ using namespace ts::server;
 VoiceClientConnection::VoiceClientConnection(VoiceClient* client) : client(client) {
     memtrack::allocated<VoiceClientConnection>(this);
 
+    this->acknowledge_handler.destroy_packet = [](void* packet) {
+        reinterpret_cast<OutgoingServerPacket*>(packet)->unref();
+    };
+
     this->crypt_handler.reset();
     debugMessage(client->getServer()->getServerId(), "Allocated new voice client connection at {}", (void*) this);
 }
 
 VoiceClientConnection::~VoiceClientConnection() {
-    /* locking here should be useless, but just to ensure! */
-    {
-        lock_guard write_queue_lock(this->write_queue_lock);
-        this->write_queue.clear();
-    }
-
-    for(auto& category : this->write_preprocess_queues) {
-        lock_guard work_lock{category.work_lock};
-        lock_guard queue_lock{category.queue_lock};
-
-        category.queue.clear();
-    }
+    this->reset();
     this->client = nullptr;
     memtrack::freed<VoiceClientConnection>(this);
 }
@@ -78,7 +71,6 @@ void VoiceClientConnection::handle_incoming_datagram(const pipes::buffer_view& b
     }
     #endif
 #endif
-
     ClientPacketParser packet_parser{buffer};
     if(!packet_parser.valid()) {
         logTrace(this->client->getServerId(), "{} Received invalid packet. Dropping.", CLIENT_STR_LOG_PREFIX_(this->client));
@@ -87,7 +79,22 @@ void VoiceClientConnection::handle_incoming_datagram(const pipes::buffer_view& b
     assert(packet_parser.type() >= 0 && packet_parser.type() < this->incoming_generation_estimators.size());
     packet_parser.set_estimated_generation(this->incoming_generation_estimators[packet_parser.type()].visit_packet(packet_parser.packet_id()));
 
+
+#ifndef CONNECTION_NO_STATISTICS
+    if(this->client) {
+        auto stats = this->client->connectionStatistics;
+        stats->logIncomingPacket(stats::ConnectionStatistics::category::from_type(packet_parser.type()), buffer.length() + 96); /* 96 for the UDP packet overhead */
+    }
+    this->packet_statistics().received_packet((protocol::PacketType) packet_parser.type(), packet_parser.full_packet_id());
+#endif
+
     auto is_command = packet_parser.type() == protocol::COMMAND || packet_parser.type() == protocol::COMMAND_LOW;
+
+    /* in previous versions we checked if the arrived packet is "worth decoding".
+     * But since in general a command buffer underflow is much more unlikely, especially because most packets are not even command packets,
+     * it's better we just skip that step and decode it anyways */
+
+#if 0
     /* pretest if the packet is worth the effort of decoding it */
     if(is_command) {
         /* handle the order stuff */
@@ -112,6 +119,7 @@ void VoiceClientConnection::handle_incoming_datagram(const pipes::buffer_view& b
             return;
         }
     }
+#endif
 
     //NOTICE I found out that the Compressed flag is set if the packet contains an audio header
 
@@ -168,11 +176,6 @@ void VoiceClientConnection::handle_incoming_datagram(const pipes::buffer_view& b
         return;
     }
 
-#ifndef CONNECTION_NO_STATISTICS
-    if(this->client && this->client->getServer())
-        this->client->connectionStatistics->logIncomingPacket(stats::ConnectionStatistics::category::from_type(packet_parser.type()), buffer.length());
-#endif
-
 #ifdef LOG_INCOMPING_PACKET_FRAGMENTS
     debugMessage(lstream << CLIENT_LOG_PREFIX << "Recived packet. PacketId: " << packet->packetId() << " PacketType: " << packet->type().name() << " Flags: " << packet->flags() << " - " << packet->data() << endl);
 #endif
@@ -191,7 +194,19 @@ void VoiceClientConnection::handle_incoming_datagram(const pipes::buffer_view& b
             unique_lock queue_lock(fragment_buffer.buffer_lock);
 
             if(!fragment_buffer.insert_index(packet_parser.packet_id(), std::move(fragment_entry))) {
-                logTrace(this->client->getServerId(), "{} Failed to insert command packet into command packet buffer.", CLIENT_STR_LOG_PREFIX_(this->client));
+                auto ignore_type = fragment_buffer.accept_index(packet_parser.packet_id());
+                debugMessage(this->client->getServerId(), "{} Dropping command packet because command assembly buffer has an {} ({}|{}|{})",
+                             CLIENT_STR_LOG_PREFIX_(this->client),
+                             ignore_type == -1 ? "underflow" : "overflow",
+                             fragment_buffer.capacity(),
+                             fragment_buffer.current_index(),
+                             packet_parser.packet_id()
+                );
+
+                if(ignore_type == -1) { /* underflow */
+                    /* we've already got the packet, but the client dosn't know that so we've to send the acknowledge again */
+                    this->client->sendAcknowledge(packet_parser.packet_id(), packet_parser.type() == protocol::COMMAND_LOW);
+                }
                 return;
             }
         }
@@ -201,8 +216,10 @@ void VoiceClientConnection::handle_incoming_datagram(const pipes::buffer_view& b
         if(voice_server)
             voice_server->schedule_command_handling(this->client);
     } else {
-        if(packet_parser.type() == protocol::VOICE || packet_parser.type() == protocol::VOICE_WHISPER)
+        if(packet_parser.type() == protocol::VOICE)
             this->client->handlePacketVoice(packet_parser);
+        else if(packet_parser.type() == protocol::VOICE_WHISPER)
+            this->client->handlePacketVoiceWhisper(packet_parser);
         else if(packet_parser.type() == protocol::ACK || packet_parser.type() == protocol::ACK_LOW)
             this->client->handlePacketAck(packet_parser);
         else if(packet_parser.type() == protocol::PING || packet_parser.type() == protocol::PONG)
@@ -252,8 +269,10 @@ void VoiceClientConnection::execute_handle_command_packets(const std::chrono::sy
         buffer_execute_lock.unlock();
 
     auto voice_server = this->client->voice_server;
-    if(voice_server && reexecute_handle)
+    if(voice_server && (reexecute_handle || this->should_reassembled_reschedule)) {
+        should_reassembled_reschedule = false;
         this->client->voice_server->schedule_command_handling(this->client);
+    }
 }
 
 /* buffer_execute_lock: lock for in order execution */
@@ -267,13 +286,19 @@ bool VoiceClientConnection::next_reassembled_command(unique_lock<std::recursive_
 
         /* handle commands before command low packets */
         for(auto& buf : this->_command_fragment_buffers) {
-            unique_lock ring_lock(buf.buffer_lock, try_to_lock);
-            if(!ring_lock.owns_lock()) continue;
+            unique_lock ring_lock(buf.buffer_lock, try_to_lock); //Perm lock the buffer else, may command wount get handeled. Because we've more left, but say we waven't
+            if(!ring_lock.owns_lock()) {
+                this->should_reassembled_reschedule = true;
+                continue;
+            }
 
             if(buf.front_set()) {
                 if(!buffer) { /* lets still test for reexecute */
                     buffer_execute_lock = unique_lock(buf.execute_lock, try_to_lock);
-                    if(!buffer_execute_lock.owns_lock()) continue;
+                    if(!buffer_execute_lock.owns_lock()) {
+                        this->should_reassembled_reschedule = true;
+                        continue;
+                    }
 
                     buffer_lock = move(ring_lock);
                     buffer = &buf;
@@ -358,267 +383,163 @@ bool VoiceClientConnection::next_reassembled_command(unique_lock<std::recursive_
         std::string error{};
 
         auto decompressed_size = compression::qlz_decompressed_size(payload.data_ptr(), payload.length());
-        auto buffer = buffer::allocate_buffer(decompressed_size);
-        if(!compression::qlz_decompress_payload(payload.data_ptr(), buffer.data_ptr(), &decompressed_size)) {
+        if(decompressed_size == 0) {
+            logTrace(this->client->getServerId(), "{} Failed to calculate decompressed size for received command. Dropping packet.", CLIENT_STR_LOG_PREFIX_(this->client));
+            return false;
+        } else if(decompressed_size > 20 * 1024 * 1024) { /* max 20MB */
+            logTrace(this->client->getServerId(), "{} Command packet has a too large compressed size. Dropping packet.", CLIENT_STR_LOG_PREFIX_(this->client));
+            return false;
+        }
+        auto decompress_buffer = buffer::allocate_buffer(decompressed_size);
+        if(!compression::qlz_decompress_payload(payload.data_ptr(), decompress_buffer.data_ptr(), &decompressed_size)) {
             logTrace(this->client->getServerId(), "{} Failed to decompress received command. Dropping packet.", CLIENT_STR_LOG_PREFIX_(this->client));
             return false;
         }
 
-        payload = buffer.range(0, decompressed_size);
+        payload = decompress_buffer.range(0, decompressed_size);
     }
 
     result = std::move(payload);
     return have_more;
 }
 
-
-void VoiceClientConnection::sendPacket(const shared_ptr<protocol::ServerPacket>& original_packet, bool copy, bool prepare_directly) {
-    if(this->client->state == ConnectionState::DISCONNECTED)
-        return;
-
-    shared_ptr<protocol::ServerPacket> packet;
-    if(copy) {
-        packet = protocol::ServerPacket::from_buffer(original_packet->buffer().dup(buffer::allocate_buffer(original_packet->buffer().length())));
-        if(original_packet->getListener())
-            packet->setListener(std::move(original_packet->getListener()));
-        packet->memory_state.flags = original_packet->memory_state.flags;
+bool VoiceClientConnection::prepare_outgoing_packet(ts::protocol::OutgoingServerPacket *packet) {
+    if(packet->type_and_flags & PacketFlag::Unencrypted) {
+        this->crypt_handler.write_default_mac(packet->mac);
     } else {
-        packet = original_packet;
-    }
+        CryptHandler::key_t crypt_key{};
+        CryptHandler::nonce_t crypt_nonce{};
+        std::string error{};
 
-    auto type = WritePreprocessCategory::from_type(packet->type().type());
-    auto& queue = this->write_preprocess_queues[type];
-    if(prepare_directly) {
-        vector<pipes::buffer> buffers;
-        this->prepare_process_count++;
-
-        {
-            unique_lock work_lock{queue.work_lock};
-            if(!this->prepare_packet_for_write(buffers, packet, work_lock)) {
-                logError(this->client->getServerId(), "{} Dropping packet!", CLIENT_STR_LOG_PREFIX_(this->client));
-                this->prepare_process_count--;
-                return;
-            }
-        }
-
-        /* enqueue buffers for write */
-        {
-            lock_guard write_queue_lock(this->write_queue_lock);
-            this->write_queue.insert(this->write_queue.end(), buffers.begin(), buffers.end());
-        }
-        this->prepare_process_count--; /* we're now done preparing */
-    } else {
-        lock_guard queue_lock{queue.queue_lock};
-        queue.queue.push_back(packet);
-        queue.has_work = true;
-    }
-    this->triggerWrite();
-}
-
-bool VoiceClientConnection::prepare_packet_for_write(vector<pipes::buffer> &result, const shared_ptr<ServerPacket> &packet, std::unique_lock<std::mutex>& work_lock) {
-    assert(work_lock.owns_lock());
-
-    string error = "success";
-
-    if(packet->type().compressable() && !packet->memory_state.fragment_entry) {
-        packet->enable_flag(PacketFlag::Compressed);
-        if(!this->compress_handler.progressPacketOut(packet.get(), error)) {
-            logError(this->getClient()->getServerId(), "{} Could not compress outgoing packet.\nThis could cause fatal failed for the client.\nError: {}", error);
-            return false;
-        }
-    }
-
-    std::vector<shared_ptr<ServerPacket>> fragments;
-    fragments.reserve((size_t) (packet->data().length() / packet->type().max_length()) + 1);
-
-    if(packet->data().length() > packet->type().max_length()) {
-        if(!packet->type().fragmentable()) {
-            logError(this->client->getServerId(), "{} We've tried to send a too long, not fragmentable, packet. Dropping packet of type {} with length {}", CLIENT_STR_LOG_PREFIX_(this->client), packet->type().name(), packet->data().length());
-            return false;
-        }
-
-        { //Split packets
-            auto buffer = packet->data();
-
-            const auto max_length = packet->type().max_length();
-            while(buffer.length() > max_length * 2) {
-                fragments.push_back(make_shared<ServerPacket>(packet->type(), buffer.view(0, max_length).dup(buffer::allocate_buffer(max_length))));
-                buffer = buffer.range((size_t) max_length);
-            }
-
-            if(buffer.length() > max_length) { //Divide rest by 2
-                fragments.push_back(make_shared<ServerPacket>(packet->type(), buffer.view(0, buffer.length() / 2).dup(buffer::allocate_buffer(buffer.length() / 2))));
-                buffer = buffer.range(buffer.length() / 2);
-            }
-            fragments.push_back(make_shared<ServerPacket>(packet->type(), buffer));
-
-            for(const auto& frag : fragments) {
-                frag->setFragmentedEntry(true);
-                frag->enable_flag(PacketFlag::NewProtocol);
-            }
-        }
-
-        assert(fragments.size() >= 2);
-        fragments.front()->enable_flag(PacketFlag::Fragmented);
-        if(packet->has_flag(PacketFlag::Compressed))
-            fragments.front()->enable_flag(PacketFlag::Compressed);
-
-        fragments.back()->enable_flag(PacketFlag::Fragmented);
-
-        if(packet->getListener())
-            fragments.back()->setListener(std::move(packet->getListener())); //Move the listener to the last :)
-    } else {
-        fragments.push_back(packet);
-    }
-
-    result.reserve(fragments.size());
-
-    /* apply packet ids */
-    for(const auto& fragment : fragments) {
-        if(!fragment->memory_state.id_branded)
-            fragment->applyPacketId(this->packet_id_manager);
-    }
-    work_lock.unlock(); /* the rest could be unordered */
-
-
-    CryptHandler::key_t crypt_key{};
-    CryptHandler::nonce_t crypt_nonce{};
-    auto statistics = this->client ? this->client->connectionStatistics : nullptr;
-    for(const auto& fragment : fragments) {
-        if(fragment->has_flag(PacketFlag::Unencrypted)) {
-            this->crypt_handler.write_default_mac(fragment->mac().data_ptr());
+        if(!this->client->crypto.protocol_encrypted) {
+            crypt_key = CryptHandler::default_key;
+            crypt_nonce = CryptHandler::default_nonce;
         } else {
-            if(!this->client->crypto.protocol_encrypted) {
-                crypt_key = CryptHandler::default_key;
-                crypt_nonce = CryptHandler::default_nonce;
-            } else {
-                if(!this->crypt_handler.generate_key_nonce(false, fragment->type().type(), fragment->packetId(), fragment->generationId(), crypt_key, crypt_nonce)) {
-                    logError(this->client->getServerId(), "{} Failed to generate crypt key/nonce for sending a packet. This should never happen! Dropping packet.", CLIENT_STR_LOG_PREFIX_(this->client));
-                    return false;
-                }
-            }
-
-            auto crypt_result = this->crypt_handler.encrypt(fragment->header().data_ptr(), fragment->header().length(),
-                                                            fragment->data().data_ptr(), fragment->data().length(),
-                                                            fragment->mac().data_ptr(),
-                                                            crypt_key, crypt_nonce, error);
-            if(!crypt_result){
-                logError(this->client->getServerId(), "{} Failed to encrypt packet. Error: {}", CLIENT_STR_LOG_PREFIX_(this->client), error);
+            if(!this->crypt_handler.generate_key_nonce(false, (uint8_t) packet->packet_type(), packet->packet_id(), packet->generation, crypt_key, crypt_nonce)) {
+                logError(this->client->getServerId(), "{} Failed to generate crypt key/nonce for sending a packet. This should never happen! Dropping packet.", CLIENT_STR_LOG_PREFIX_(this->client));
                 return false;
             }
         }
 
-#ifndef CONNECTION_NO_STATISTICS
-        if(statistics)
-            statistics->logOutgoingPacket(*fragment);
-#endif
-        this->acknowledge_handler.process_packet(*fragment);
-        result.push_back(fragment->buffer());
+        auto crypt_result = this->crypt_handler.encrypt((char*) packet->packet_data() + ServerPacketP::kHeaderOffset, ServerPacketP::kHeaderLength,
+                                                        packet->payload, packet->payload_size,
+                                                        packet->mac,
+                                                        crypt_key, crypt_nonce, error);
+        if(!crypt_result){
+            logError(this->client->getServerId(), "{} Failed to encrypt packet. Error: {}", CLIENT_STR_LOG_PREFIX_(this->client), error);
+            return false;
+        }
     }
-
     return true;
 }
 
-bool VoiceClientConnection::preprocess_write_packets() {
-    std::shared_ptr<ServerPacket> packet{nullptr};
-    vector<pipes::buffer> buffers{};
-    bool flag_more{false};
+VoiceClientConnection::WBufferPopResult VoiceClientConnection::pop_write_buffer(protocol::OutgoingServerPacket *&result) {
+    if(this->client->state == ConnectionState::DISCONNECTED)
+        return WBufferPopResult::DRAINED;
 
-    prepare_process_count++; /* we're not preparing a packet */
-    for(auto& category : this->write_preprocess_queues) {
-        if(!category.has_work) continue;
-        else if(packet) {
-            flag_more = true;
-            break;
-        }
-
-        unique_lock work_lock{category.work_lock, try_to_lock};
-        if(!work_lock) continue; /* This particular category will already be processed */
-
-        {
-            lock_guard buffer_lock{category.queue_lock};
-            if(category.queue.empty()) {
-                category.has_work = false;
-                continue;
+    bool need_prepare_packet{false}, more_packets{false};
+    {
+        std::lock_guard wlock{this->write_queue_mutex};
+        if(this->resend_queue_head) {
+            result = this->resend_queue_head;
+            if(result->next) {
+                assert(this->resend_queue_tail != &result->next);
+                this->resend_queue_head = result->next;
+            } else {
+                assert(this->resend_queue_tail == &result->next);
+                this->resend_queue_head = nullptr;
+                this->resend_queue_tail = &this->resend_queue_head;
             }
-
-            packet = std::move(category.queue.front());
-            category.queue.pop_front();
-            category.has_work = !category.queue.empty();
-            flag_more = category.has_work;
+        } else if(this->write_queue_head) {
+            result = this->write_queue_head;
+            if(result->next) {
+                assert(this->write_queue_tail != &result->next);
+                this->write_queue_head = result->next;
+            } else {
+                assert(this->write_queue_tail == &result->next);
+                this->write_queue_head = nullptr;
+                this->write_queue_tail = &this->write_queue_head;
+            }
+            need_prepare_packet = true;
+        } else {
+            return WBufferPopResult::DRAINED;
         }
-
-        if(!this->prepare_packet_for_write(buffers, packet, work_lock)) {
-            logError(this->client->getServerId(), "{} Dropping packet!", CLIENT_STR_LOG_PREFIX_(this->client));
-            if(flag_more)
-                break;
-            else
-                continue; /* find out if we have more */
-        }
-
-        if(flag_more)
-            break;
-        else
-            continue; /* find out if we have more */
+        result->next = nullptr;
+        more_packets = this->resend_queue_head != nullptr || this->write_queue_head != nullptr;
     }
 
-    /* enqueue buffers for write */
-    if(!buffers.empty()) {
-        lock_guard write_queue_lock(this->write_queue_lock);
-        this->write_queue.insert(this->write_queue.end(), buffers.begin(), buffers.end());
-    }
-    this->prepare_process_count--; /* we're now done preparing */
-
-    return flag_more;
+    if(need_prepare_packet)
+        this->prepare_outgoing_packet(result);
+    return more_packets ? WBufferPopResult::MORE_AVAILABLE : WBufferPopResult::DRAINED;
 }
 
-int VoiceClientConnection::pop_write_buffer(pipes::buffer& target) {
-    if(this->client->state == DISCONNECTED)
-        return 2;
+void VoiceClientConnection::execute_resend(const std::chrono::system_clock::time_point &now, std::chrono::system_clock::time_point &next) {
+    std::deque<std::shared_ptr<connection::AcknowledgeManager::Entry>> buffers{};
+    std::string error{};
 
-    lock_guard write_queue_lock(this->write_queue_lock);
-    size_t size = this->write_queue.size();
-    if(size == 0)
-        return 2;
+    if (this->acknowledge_handler.execute_resend(now, next, buffers, error) < 0) {
+        debugMessage(client->getServerId(), "{} Failed to execute packet resend: {}", CLIENT_STR_LOG_PREFIX_(this->client), error);
 
-    target = std::move(this->write_queue.front());
-    this->write_queue.pop_front();
-
-#ifdef FUZZING_TESTING_OUTGOING
-    #ifdef FIZZING_TESTING_DISABLE_HANDSHAKE
-    if (this->client->state == ConnectionState::CONNECTED) {
-        #endif
-        if ((rand() % FUZZING_TESTING_DROP_MAX) < FUZZING_TESTING_DROP) {
-            debugMessage(this->client->getServerId(), "{}[FUZZING] Dropping outgoing packet", CLIENT_STR_LOG_PREFIX_(this->client));
-            return 0;
+        if(this->client->state == ConnectionState::CONNECTED) {
+            this->client->disconnect(ViewReasonId::VREASON_TIMEOUT, config::messages::timeout::packet_resend_failed, nullptr, true);
+        } else {
+            this->client->close_connection(system_clock::now() + seconds(1));
         }
-        #ifdef FIZZING_TESTING_DISABLE_HANDSHAKE
+    } else if(!buffers.empty()) {
+        size_t send_count{0};
+        {
+            lock_guard wlock{this->write_queue_mutex};
+            for(auto& buffer : buffers) {
+                auto packet = (protocol::OutgoingServerPacket*) buffer->packet_ptr;
+                if(packet->next) continue; /* still in write queue (this shall not happen very often) */
+                if(&packet->next == this->write_queue_tail || &packet->next == this->resend_queue_tail) continue;
+
+                packet->ref(); /* for the write queue again */
+                *this->resend_queue_tail = packet;
+                this->resend_queue_tail = &packet->next;
+
+                send_count++;
+                buffer->resend_count++;
+                this->packet_statistics().send_command((protocol::PacketType) buffer->packet_type, buffer->packet_full_id);
+            }
+        }
+        logTrace(client->getServerId(), "{} Resending {} packets. Send actually {} packets.", CLIENT_STR_LOG_PREFIX_(client), buffers.size(), send_count);
+        this->triggerWrite();
+    }
+}
+
+void VoiceClientConnection::encrypt_write_queue() {
+    OutgoingServerPacket* packets_head, *packets_tail;
+    {
+        std::lock_guard wlock{this->write_queue_mutex};
+        packets_head = this->write_queue_head;
+        this->write_queue_head = nullptr;
+        this->write_queue_tail = &this->write_queue_head;
+    }
+    if(!packets_head) return;
+
+    auto packet = packets_head;
+    while(packet) {
+        this->prepare_outgoing_packet(packet);
+        packets_tail = packet;
+        packet = packet->next;
+    }
+
+    {
+        std::lock_guard wlock{this->write_queue_mutex};
+        *this->resend_queue_tail = packets_head;
+        this->resend_queue_tail = &packets_tail->next;
     }
-    #endif
-#endif
-    return size > 1;
 }
 
 bool VoiceClientConnection::wait_empty_write_and_prepare_queue(chrono::time_point<chrono::system_clock> until) {
     while(true) {
-        for(auto& queue : this->write_preprocess_queues) {
-            {
-                lock_guard lock{queue.queue_lock};
-                if(!queue.queue.empty())
-                    goto _wait;
-            }
-
-            {
-                unique_lock lock{queue.work_lock, try_to_lock};
-                if(!lock.owns_lock())
-                    goto _wait;
-            }
-        }
         {
-            lock_guard buffer_lock{this->write_queue_lock};
-            if(!this->write_queue.empty())
+            std::lock_guard wlock{this->write_queue_mutex};
+            if(this->write_queue_head)
                 goto _wait;
-            if(this->prepare_process_count != 0)
+
+            if(this->resend_queue_head)
                 goto _wait;
         }
         break;
@@ -633,11 +554,25 @@ bool VoiceClientConnection::wait_empty_write_and_prepare_queue(chrono::time_poin
 }
 
 void VoiceClientConnection::reset() {
-    for(auto& queue : this->write_preprocess_queues) {
-        {
-            lock_guard lock{queue.queue_lock};
-            queue.queue.clear();
+    {
+        std::lock_guard wlock{this->write_queue_mutex};
+        auto head = this->write_queue_head;
+        while(head) {
+            auto next = head->next;
+            head->unref();
+            head = next;
         }
+        this->write_queue_head = nullptr;
+        this->write_queue_tail = &this->write_queue_head;
+
+        head = this->resend_queue_head;
+        while(head) {
+            auto next = head->next;
+            head->unref();
+            head = next;
+        }
+        this->resend_queue_head = nullptr;
+        this->resend_queue_tail = &this->resend_queue_head;
     }
 
     this->acknowledge_handler.reset();
@@ -677,4 +612,163 @@ void VoiceClientConnection::register_initiv_packet() {
     auto& fragment_buffer = this->_command_fragment_buffers[command_fragment_buffer_index(protocol::COMMAND)];
     unique_lock buffer_lock(fragment_buffer.buffer_lock);
     fragment_buffer.set_full_index_to(1); /* the first packet (0) is already the clientinitiv packet */
+}
+
+void VoiceClientConnection::send_packet(protocol::OutgoingServerPacket *packet) {
+    uint32_t full_id;
+    {
+        std::lock_guard id_lock{this->packet_id_mutex};
+        full_id = this->packet_id_manager.generate_full_id(packet->packet_type());
+    }
+    packet->set_packet_id(full_id & 0xFFFFU);
+    packet->generation = full_id >> 16U;
+
+    {
+        std::lock_guard qlock{this->write_queue_mutex};
+        *this->write_queue_tail = packet;
+        this->write_queue_tail = &packet->next;
+    }
+
+    auto statistics = this->client ? this->client->connectionStatistics : nullptr;
+    if(statistics) {
+        auto category = stats::ConnectionStatistics::category::from_type(packet->packet_type());
+        statistics->logOutgoingPacket(category, packet->packet_length() + 96); /* 96 for the UDP packet overhead */
+    }
+
+    this->triggerWrite();
+}
+
+void VoiceClientConnection::send_packet(protocol::PacketType type, protocol::PacketFlag::PacketFlags flag, const void *payload, size_t payload_size) {
+    auto packet = protocol::allocate_outgoing_packet(payload_size);
+
+    packet->type_and_flags = (uint8_t) type | (uint8_t) flag;
+    memcpy(packet->payload, payload, payload_size);
+
+    this->send_packet(packet);
+}
+
+#define MAX_COMMAND_PACKET_PAYLOAD_LENGTH (487)
+void VoiceClientConnection::send_command(const std::string_view &command, bool low, std::unique_ptr<threads::Future<bool>> ack_listener) {
+    bool own_data_buffer{false};
+    void* own_data_buffer_ptr; /* imutable! */
+
+    const char* data_buffer{command.data()};
+    size_t data_length{command.length()};
+
+    uint8_t head_pflags{0};
+    PacketType ptype{low ? PacketType::COMMAND_LOW : PacketType::COMMAND};
+    protocol::OutgoingServerPacket *packets_head{nullptr};
+    protocol::OutgoingServerPacket **packets_tail{&packets_head};
+
+    /* only compress "long" commands */
+    if(command.size() > 100) {
+        size_t max_compressed_payload_size = compression::qlz_compressed_size(command.data(), command.length());
+        auto compressed_buffer = ::malloc(max_compressed_payload_size);
+
+        size_t compressed_size{max_compressed_payload_size};
+        if(!compression::qlz_compress_payload(command.data(), command.length(), compressed_buffer, &compressed_size)) {
+            logCritical(0, "Failed to compress command packet. Dropping packet");
+            ::free(compressed_buffer);
+            return;
+        }
+
+        /* we don't need to make the command longer than it is */
+        if(compressed_size < command.length() || this->client->getType() == ClientType::CLIENT_TEAMSPEAK) { /* TS3 requires each splituped packet to be compressed (Update: Not 100% sure since there was another bug when discovering this but I've kept it since) */
+            own_data_buffer = true;
+            data_buffer = (char*) compressed_buffer;
+            own_data_buffer_ptr = compressed_buffer;
+            data_length = compressed_size;
+            head_pflags |= PacketFlag::Compressed;
+        } else {
+            ::free(compressed_buffer);
+        }
+    }
+
+    uint8_t ptype_and_flags{(uint8_t) ((uint8_t) ptype | (uint8_t) PacketFlag::NewProtocol)};
+    if(data_length > MAX_COMMAND_PACKET_PAYLOAD_LENGTH) {
+        auto chunk_count = (size_t) ceil((float) data_length / (float) MAX_COMMAND_PACKET_PAYLOAD_LENGTH);
+        auto chunk_size = (size_t) ceil((float) data_length / (float) chunk_count);
+
+        while(true) {
+            auto bytes = min(chunk_size, data_length);
+            auto packet = protocol::allocate_outgoing_packet(bytes);
+            packet->type_and_flags = ptype_and_flags;
+            memcpy(packet->payload, data_buffer, bytes);
+
+            *packets_tail = packet;
+            packets_tail = &packet->next;
+
+            data_length -= bytes;
+            if(data_length == 0) {
+                packet->type_and_flags |= PacketFlag::Fragmented;
+                break;
+            }
+            data_buffer += bytes;
+        }
+        packets_head->type_and_flags |= PacketFlag::Fragmented;
+    } else {
+        auto packet = protocol::allocate_outgoing_packet(data_length);
+        packet->type_and_flags = ptype_and_flags;
+
+        memcpy(packet->payload, data_buffer, data_length);
+
+        packets_head = packet;
+        packets_tail = &packet->next;
+    }
+
+
+    {
+        std::lock_guard id_lock{this->packet_id_mutex};
+        uint32_t full_id;
+        auto head = packets_head;
+        while(head) {
+            full_id = this->packet_id_manager.generate_full_id(ptype);
+
+            head->set_packet_id(full_id & 0xFFFFU);
+            head->generation = full_id >> 16U;
+            head = head->next;
+        }
+    }
+    packets_head->type_and_flags |= head_pflags;
+
+    /* do this before the next ptr might get modified due to the write queue */
+    auto statistics = this->client ? this->client->connectionStatistics : nullptr;
+    /* general stats */
+    if(statistics) {
+        auto head = packets_head;
+        while(head) {
+            statistics->logOutgoingPacket(stats::ConnectionStatistics::category::COMMAND, head->packet_length() + 96); /* 96 for the UDP overhead */
+            head = head->next;
+        }
+    }
+
+    /* loss stats */
+    {
+        auto head = packets_head;
+        while(head) {
+            auto full_packet_id = (uint32_t) (head->generation << 16U) | head->packet_id();
+            this->packet_statistics_.send_command(head->packet_type(), full_packet_id);
+
+            /* increase a reference for the ack handler */
+            head->ref();
+
+            /* Even thou the packet is yet unencrypted, it will be encrypted with the next write. The next write will be before the next resend because the next ptr must be null in order to resend a packet */
+            if(&head->next == packets_tail)
+                this->acknowledge_handler.process_packet(ptype, full_packet_id, head, std::move(ack_listener));
+            else
+                this->acknowledge_handler.process_packet(ptype, full_packet_id, head, nullptr);
+
+            head = head->next;
+        }
+    }
+
+    {
+        std::lock_guard qlock{this->write_queue_mutex};
+        *this->write_queue_tail = packets_head;
+        this->write_queue_tail = packets_tail;
+    }
+    this->triggerWrite();
+
+    if(own_data_buffer)
+        ::free(own_data_buffer_ptr);
 }

server/src/client/voice/VoiceClientConnection.h

@@ -15,6 +15,7 @@
 #include "VoiceClient.h"
 #include "protocol/AcknowledgeManager.h"
 #include <protocol/generation.h>
+#include "./PacketStatistics.h"
 
 //#define LOG_ACK_SYSTEM
 #ifdef LOG_ACK_SYSTEM
@@ -38,6 +39,11 @@ namespace ts {
                 friend class server::VoiceClient;
                 friend class server::POWHandler;
             public:
+                enum struct WBufferPopResult {
+                    DRAINED,
+                    MORE_AVAILABLE
+                };
+
                 struct CommandFragment {
                     uint16_t packet_id{0};
                     uint16_t packet_generation{0};
@@ -62,7 +68,10 @@ namespace ts {
                 explicit VoiceClientConnection(server::VoiceClient*);
                 virtual ~VoiceClientConnection();
 
-                void sendPacket(const std::shared_ptr<protocol::ServerPacket>& original_packet, bool copy = false, bool prepare_directly = false);
+                /* Do not send command packets via send_packet! The send_packet will take ownership of the packet! */
+                void send_packet(protocol::OutgoingServerPacket* /* packet */);
+                void send_packet(protocol::PacketType /* type */, protocol::PacketFlag::PacketFlags /* flags */, const void* /* payload */, size_t /* payload length */);
+                void send_command(const std::string_view& /* build command command */, bool /* command low */, std::unique_ptr<threads::Future<bool>> /* acknowledge listener */);
 
                 CryptHandler* getCryptHandler(){ return &crypt_handler; }
 
@@ -71,21 +80,22 @@ namespace ts {
 #ifdef VC_USE_READ_QUEUE
                 bool handleNextDatagram();
 #endif
-                /*
-                 * Split packets waiting in write_process_queue and moves the final buffers to writeQueue.
-                 * @returns true when there are more packets to prepare
-                 */
-                bool preprocess_write_packets();
-                /* return 2 => Nothing | 1 => More and buffer is set | 0 => Buffer is set, nothing more */
-                int pop_write_buffer(pipes::buffer& /* buffer */);
+                /* if the result is true, ownership has been transferred */
+                WBufferPopResult pop_write_buffer(protocol::OutgoingServerPacket*& /* packet */);
+                void execute_resend(const std::chrono::system_clock::time_point &now, std::chrono::system_clock::time_point &next);
 
+                void encrypt_write_queue();
                 bool wait_empty_write_and_prepare_queue(std::chrono::time_point<std::chrono::system_clock> until = std::chrono::time_point<std::chrono::system_clock>());
 
                 protocol::PacketIdManager& getPacketIdManager() { return this->packet_id_manager; }
+                AcknowledgeManager& getAcknowledgeManager() { return this->acknowledge_handler; }
+                inline auto& get_incoming_generation_estimators() { return this->incoming_generation_estimators; }
                 void reset();
 
                 void force_insert_command(const pipes::buffer_view& /* payload */);
                 void register_initiv_packet();
+
+                [[nodiscard]] inline auto& packet_statistics() { return this->packet_statistics_; }
                 //buffer::SortedBufferQueue<protocol::ClientPacket>** getReadQueue() { return this->readTypedQueue; }
             protected:
                 void handle_incoming_datagram(const pipes::buffer_view &buffer);
@@ -100,69 +110,29 @@ namespace ts {
                 CompressionHandler compress_handler;
                 AcknowledgeManager acknowledge_handler;
 
+                std::atomic_bool should_reassembled_reschedule{}; /* this get checked as soon the command handle lock has been released so trylock will succeed */
+
                 //Handle stuff
                 void execute_handle_command_packets(const std::chrono::system_clock::time_point& /* scheduled */);
                 bool next_reassembled_command(std::unique_lock<std::recursive_timed_mutex> &buffer_execute_lock /* packet channel execute lock */, pipes::buffer & /* buffer*/, uint16_t& /* packet id */);
 
 
-                /* ---------- Write declarations ---------- */
-                spin_lock write_queue_lock; /* queue access isn't for long in general */
-                std::deque<pipes::buffer> write_queue;
+                /* ---------- Write ---------- */
+                spin_mutex write_queue_mutex{};
+                protocol::OutgoingServerPacket* resend_queue_head{nullptr};
+                protocol::OutgoingServerPacket** resend_queue_tail{&resend_queue_head};
 
-                struct WritePreprocessCategory {
-                    enum value {
-                        PING_PONG = 0, //Ping/Pongs
-                        ACK = 2,
-                        VOICE_WHISPER = 1, //Voice/Whisper
-                        COMMAND = 3,
-                        INIT = 4,
-
-                        MAX = INIT
-                    };
-
-                    inline static value from_type(protocol::PacketType type) {
-                        switch(type) {
-                            case protocol::PING:
-                            case protocol::PONG:
-                                return value::PING_PONG;
-
-                            case protocol::VOICE:
-                            case protocol::VOICE_WHISPER:
-                                return value::VOICE_WHISPER;
-
-                            case protocol::ACK:
-                            case protocol::ACK_LOW:
-                                return value::ACK;
-
-                            case protocol::COMMAND:
-                            case protocol::COMMAND_LOW:
-                                return value::COMMAND;
-
-                            default:
-                                return value::INIT;
-                        }
-                    }
-                };
-
-                struct WritePreprocessQueue {
-                    int _zero1{0};
-                    bool has_work{false};
-                    std::mutex work_lock{};
-
-                    spin_lock queue_lock{};
-                    std::deque<std::shared_ptr<protocol::ServerPacket>> queue{};
-
-                    int _zero{0};
-                };
-                std::array<WritePreprocessQueue, WritePreprocessCategory::MAX> write_preprocess_queues{};
+                protocol::OutgoingServerPacket* write_queue_head{nullptr};
+                protocol::OutgoingServerPacket** write_queue_tail{&write_queue_head};
 
                 /* ---------- Processing ---------- */
                 /* automatically locked because packets of the same kind should be lock their "work_lock" from their WritePreprocessQueue object */
                 protocol::PacketIdManager packet_id_manager;
+                spin_mutex packet_id_mutex{};
 
                 /* this function is thread save :) */
                 std::atomic<uint8_t> prepare_process_count{0}; /* current thread count preparing a packet */
-                bool prepare_packet_for_write(std::vector<pipes::buffer> &/* buffers which need to be transferred */, const std::shared_ptr<protocol::ServerPacket> &/* the packet */, std::unique_lock<std::mutex>& /* work lock */);
+                bool prepare_outgoing_packet(protocol::OutgoingServerPacket* /* packet */);
 
                 std::array<protocol::generation_estimator, 9> incoming_generation_estimators{}; /* implementation is thread save */
                 std::recursive_mutex packet_buffer_lock;
@@ -172,6 +142,7 @@ namespace ts {
                     return packet_index & 0x1U; /* use 0 for command and 1 for command low */
                 }
 
+                server::client::PacketStatistics packet_statistics_{};
         };
     }
 }

server/src/client/voice/VoiceClientHandschake.cpp

@@ -70,6 +70,7 @@ ts::command_result VoiceClient::handleCommandClientInitIv(Command& command) {
 
     this->connection->reset();
     this->connection->register_initiv_packet();
+    this->connection->packet_statistics().reset_offsets();
     this->crypto.protocol_encrypted = false;
 
     bool use_teaspeak = command.hasParm("teaspeak");
@@ -166,7 +167,8 @@ ts::command_result VoiceClient::handleCommandClientInitIv(Command& command) {
             } else {
                 this->handshake.state = HandshakeState::SUCCEEDED; /* we're doing the verify via TeamSpeak */
             }
-            this->sendCommand0(initivexpand.build(), false, true); //If we setup the encryption now
+            this->sendCommand0(initivexpand.build()); //If we setup the encryption now
+            this->connection->encrypt_write_queue();
         }
 
         {