Efficiency improvements (#31)

* replace libwebsockets with libtws
* enable app level compression

Author: chemwolf6922

.github/workflows/ci.yml

@@ -36,6 +36,7 @@ env:
     TestUtf8
     TestUuid
     TestWorkerThread
+    TestZstdMessageCodec
 
 jobs:
   build-and-test:
@@ -55,12 +56,12 @@ jobs:
             curl \
             git \
             libcurl4-openssl-dev \
-            libwebsockets-dev \
             libsqlite3-dev \
             uuid-dev \
             nlohmann-json3-dev \
             libssl-dev \
-            valgrind
+            valgrind \
+            libzstd-dev
 
       - name: Install libsodium (>=1.0.19) from source
         run: |
@@ -91,6 +92,15 @@ jobs:
           cmake --build /tmp/js-style-co-routine/build --parallel
           sudo cmake --install /tmp/js-style-co-routine/build
           sudo ldconfig
+      
+      - name: Install tiny-websocket from source
+        run: |
+          set -euo pipefail
+          git clone --depth=1 --recursive https://github.com/chemwolf6922/tiny-websocket /tmp/tiny-websocket
+          cmake -S /tmp/tiny-websocket -B /tmp/tiny-websocket/build -DCMAKE_BUILD_TYPE="$BUILD_TYPE" -DCMAKE_POSITION_INDEPENDENT_CODE=ON
+          cmake --build /tmp/tiny-websocket/build --parallel
+          sudo cmake --install /tmp/tiny-websocket/build
+          sudo ldconfig
 
       - name: Configure main build
         run: cmake -S . -B build -DCMAKE_BUILD_TYPE="$BUILD_TYPE"

CMakeLists.txt

@@ -45,10 +45,11 @@ target_include_directories(tui-server
 target_link_libraries(tui-server
     PRIVATE
         curl
-        websockets
+        tws
         sqlite3
         uuid
-        sodium)
+        sodium
+        zstd)
 
 add_executable(tui-register
     ${CMAKE_CURRENT_SOURCE_DIR}/src/tui-register.cpp

README.md

@@ -1,15 +1,14 @@
 ## Prerequisites
 Install the following packages from your package manager:
 * libcurl
-* libwebsockets
 * libsqlite3
 * libuuid
 * nlohmann-json
 * libsodium (>=1.0.19)
 
 For example, on debian, these can be installed:
 ```bash
-sudo apt install libcurl4-openssl-dev libwebsockets-dev libsqlite3-dev  uuid-dev nlohmann-json3-dev
+sudo apt install libcurl4-openssl-dev libsqlite3-dev  uuid-dev nlohmann-json3-dev
 ```
 Install the following packages from source:
 * [libtev-cpp](https://github.com/chemwolf6922/tiny-event-loop-cpp)
@@ -32,6 +31,16 @@ cmake ..
 make
 sudo make install
 ```
+* [tiny-websocket](https://github.com/chemwolf6922/tiny-websocket)
+```bash
+git clone https://github.com/chemwolf6922/tiny-websocket
+cd tiny-websocket
+mkdir build
+cd build
+cmake ..
+make
+sudo make install
+```
 * [libsodium](https://github.com/jedisct1/libsodium)<br>
 Distros like debian and ubuntu only have the older version of libsodium available in their package manager. Thus, you may need to install the latest stable libsodium from source to a local location. And build and run tui-server against it.
 ```bash

src/application/IMessageCodec.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <vector>
+#include <cstdint>
+
+namespace TUI::Application
+{
+
+    class IMessageCodec
+    {
+    public:
+        virtual ~IMessageCodec() = default;
+
+        virtual std::vector<std::uint8_t> Encode(const std::vector<std::uint8_t>& data) = 0;
+        virtual std::vector<std::uint8_t> Decode(const std::vector<std::uint8_t>& data) = 0;
+    };
+
+}

src/application/SecureSession.cpp

@@ -13,17 +13,50 @@ using namespace TUI::Network;
 using namespace TUI::Application;
 using namespace TUI::Application::SecureSession;
 
+namespace
+{
+
+    class EncryptionCodec : public IMessageCodec
+    {
+    public:
+        EncryptionCodec(
+            Cipher::ChaCha20Poly1305::Encryptor encryptor,
+            Cipher::ChaCha20Poly1305::Decryptor decryptor)
+            : _encryptor(std::move(encryptor)), _decryptor(std::move(decryptor))
+        {
+        }
+        ~EncryptionCodec() override = default;
+        EncryptionCodec(const EncryptionCodec&) = delete;
+        EncryptionCodec& operator=(const EncryptionCodec&) = delete;
+        EncryptionCodec(EncryptionCodec&&) = delete;
+        EncryptionCodec& operator=(EncryptionCodec&&) = delete;
+
+        std::vector<std::uint8_t> Encode(const std::vector<std::uint8_t>& data) override
+        {
+            return _encryptor.Encrypt(data);
+        }
+
+        std::vector<std::uint8_t> Decode(const std::vector<std::uint8_t>& data) override
+        {
+            return _decryptor.Decrypt(data);
+        }
+
+    private:
+        Cipher::ChaCha20Poly1305::Encryptor _encryptor;
+        Cipher::ChaCha20Poly1305::Decryptor _decryptor;
+    };
+
+}
+
 /** Session */
 
 Connection::Connection(
     std::shared_ptr<IConnection<void>> connection,
     const CallerId& callerId,
-    Cipher::ChaCha20Poly1305::Encryptor encryptor,
-    Cipher::ChaCha20Poly1305::Decryptor decryptor,
-    bool turnOffEncryption,
-    std::function<void(CallerId)> onClose)
-    : _connection(std::move(connection)), _callerId(callerId), _encryptor(std::move(encryptor)),
-      _decryptor(std::move(decryptor)), _turnOffEncryption(turnOffEncryption), _onClose(std::move(onClose))
+    std::function<void(CallerId)> onClose,
+    const std::vector<std::shared_ptr<IMessageCodec>>& messageCodecs)
+    : _connection(std::move(connection)), _callerId(callerId), _onClose(std::move(onClose)),
+      _messageCodecs(messageCodecs)
 {
     if (_connection == nullptr)
     {
@@ -62,9 +95,9 @@ void Connection::Send(std::vector<std::uint8_t> message)
     {
         throw std::runtime_error("Connection is closed");
     }
-    if (!_turnOffEncryption)
+    for (const auto& codec : _messageCodecs)
     {
-        message = _encryptor.Encrypt(message);
+        message = codec->Encode(message);
     }
     _connection->Send(std::move(message));
 }
@@ -82,9 +115,9 @@ JS::Promise<std::optional<std::vector<std::uint8_t>>> Connection::ReceiveAsync()
         co_return std::nullopt;
     }
     auto data = std::move(dataOpt.value());
-    if (!_turnOffEncryption)
+    for (auto it = _messageCodecs.rbegin(); it != _messageCodecs.rend(); ++it)
     {
-        data = _decryptor.Decrypt(data);
+        data = (*it)->Decode(data);
     }
     co_return std::move(data);
 }
@@ -99,16 +132,18 @@ CallerId Connection::GetId() const
 std::shared_ptr<IServer<CallerId>> Server::Create(
     Tev& tev,
     std::shared_ptr<IServer<void>> server,
-    GetUserCredentialFunc getUserCredential)
+    GetUserCredentialFunc getUserCredential,
+    const std::vector<std::shared_ptr<IMessageCodec>>& messageCodecs)
 {
-    return std::shared_ptr<Server>(new Server(tev, server, getUserCredential));
+    return std::shared_ptr<Server>(new Server(tev, server, getUserCredential, messageCodecs));
 }
 
 Server::Server(
     Tev& tev,
     std::shared_ptr<IServer<void>> server,
-    GetUserCredentialFunc getUserCredential)
-    : _tev(tev), _server(server), _getUserCredential(getUserCredential)
+    GetUserCredentialFunc getUserCredential,
+    const std::vector<std::shared_ptr<IMessageCodec>>& messageCodecs)
+    : _tev(tev), _server(server), _getUserCredential(getUserCredential), _messageCodecs(messageCodecs)
 {
     if (server == nullptr || getUserCredential == nullptr)
     {
@@ -346,12 +381,14 @@ JS::Promise<void> Server::HandleHandshakeAsync(std::shared_ptr<IConnection<void>
                 connection->Send(std::move(negotiationResponseCipher));
                 /** Create the secure connection */
                 std::weak_ptr<Server> weakThis = shared_from_this();
-                auto secureConnection = std::make_shared<Connection>(
-                    connection,
+                std::vector<std::shared_ptr<IMessageCodec>> codecs = _messageCodecs;
+                if (!negotiationRequest.get_turn_off_encryption())
+                {
+                    codecs.push_back(std::make_shared<EncryptionCodec>(std::move(encryptor), std::move(decryptor)));
+                }
+                auto secureConnection = std::shared_ptr<Connection>(new Connection(
+                    std::move(connection),
                     callerId,
-                    encryptor,
-                    decryptor,
-                    negotiationRequest.get_turn_off_encryption(),
                     [weakThis, resumptionKeyIndex](CallerId id) {
                         auto self = weakThis.lock();
                         if (!self)
@@ -379,7 +416,8 @@ JS::Promise<void> Server::HandleHandshakeAsync(std::shared_ptr<IConnection<void>
                         self->_resumptionKeyTimeouts.emplace(
                             resumptionKeyIndexStr,
                             std::move(resumptionKeyTimeout));
-                    });
+                    },
+                    std::move(codecs)));
                 _connections.emplace(callerId, secureConnection);
                 /** Add the connection to the generator */
                 _connectionGenerator.Feed(secureConnection);

src/application/SecureSession.h

@@ -16,20 +16,16 @@
 #include "cipher/FakeCredentialGenerator.h"
 #include "cipher/BruteForceLimiter.h"
 #include "common/Cache.h"
+#include "IMessageCodec.h"
 
 namespace TUI::Application::SecureSession
 {
+    class Server;
+
     class Connection : public Network::IConnection<CallerId>
     {
+        friend class Server;
     public:
-        /** @todo Compression? */
-        Connection(
-            std::shared_ptr<Network::IConnection<void>> connection,
-            const CallerId& callerId,
-            Cipher::ChaCha20Poly1305::Encryptor encryptor,
-            Cipher::ChaCha20Poly1305::Decryptor decryptor,
-            bool turnOffEncryption,
-            std::function<void(CallerId)> onClose);
         ~Connection() override;
         Connection(const Connection&) = delete;
         Connection& operator=(const Connection&) = delete;
@@ -43,13 +39,17 @@ namespace TUI::Application::SecureSession
         CallerId GetId() const override;
 
     private:
+        Connection(
+            std::shared_ptr<Network::IConnection<void>> connection,
+            const CallerId& callerId,
+            std::function<void(CallerId)> onClose,
+            const std::vector<std::shared_ptr<IMessageCodec>>& messageCodecs);
+
         std::shared_ptr<Network::IConnection<void>> _connection;
         CallerId _callerId;
-        Cipher::ChaCha20Poly1305::Encryptor _encryptor;
-        Cipher::ChaCha20Poly1305::Decryptor _decryptor;
-        bool _turnOffEncryption;
         std::function<void(CallerId)> _onClose;
         bool _closed{false};
+        std::vector<std::shared_ptr<IMessageCodec>> _messageCodecs{};
     };
 
     class Server : public Network::IServer<CallerId>, public std::enable_shared_from_this<Server>
@@ -71,7 +71,8 @@ namespace TUI::Application::SecureSession
         static std::shared_ptr<Network::IServer<CallerId>> Create(
             Tev& tev,
             std::shared_ptr<Network::IServer<void>> server,
-            GetUserCredentialFunc getUserCredential);
+            GetUserCredentialFunc getUserCredential,
+            const std::vector<std::shared_ptr<IMessageCodec>>& messageCodecs = {});
         ~Server() override;
         Server(const Server&) = delete;
         Server& operator=(const Server&) = delete;
@@ -94,11 +95,13 @@ namespace TUI::Application::SecureSession
         Cipher::FakeCredentialGenerator _fakeCredentialGenerator{10000};
         /** 5 trials per window, 5 min to 6 hours of lock out time. */
         Cipher::BruteForceLimiter _bruteForceLimiter{5, 5 * 60 * 1000, 6 * 60 * 60 * 1000};
+        std::vector<std::shared_ptr<IMessageCodec>> _messageCodecs{};
 
         Server(
             Tev& tev,
             std::shared_ptr<Network::IServer<void>> server,
-            GetUserCredentialFunc getUserCredential);
+            GetUserCredentialFunc getUserCredential,
+            const std::vector<std::shared_ptr<IMessageCodec>>& messageCodecs);
 
         JS::Promise<void> HandleRawConnections();
         JS::Promise<void> HandleHandshakeAsync(std::shared_ptr<Network::IConnection<void>> connection);