Feature/rb 143 compression pack network

deps/CMakeLists.txt

@@ -4,3 +4,4 @@ add_subdirectory(raylib)
 add_subdirectory(boost)
 add_subdirectory(json)
 add_subdirectory(date)
+add_subdirectory(zstd)

deps/zstd/CMakeLists.txt

@@ -0,0 +1,27 @@
+cmake_minimum_required(VERSION 3.15)
+
+include(FetchContent)
+
+set(ZSTD_BUILD_STATIC ON)
+set(ZSTD_BUILD_SHARED OFF)
+
+FetchContent_Declare(
+    zstd
+    URL "https://github.com/facebook/zstd/releases/download/v1.5.5/zstd-1.5.5.tar.gz"
+    DOWNLOAD_EXTRACT_TIMESTAMP TRUE
+    SOURCE_SUBDIR build/cmake
+)
+
+FetchContent_MakeAvailable(zstd)
+
+target_link_libraries(
+    ${PROJECT_NAME_CLIENT}
+    PRIVATE
+    libzstd_static
+)
+
+target_link_libraries(
+    ${PROJECT_NAME_SERVER}
+    PRIVATE
+    libzstd_static
+)

src/Nitwork/ANitwork.cpp

@@ -126,6 +126,7 @@ namespace Nitwork {
 
     void ANitwork::callReceiveHandler(const std::string &message)
     {
+        Logger::error("NITWORK: " + message);
         startReceiveHandler();
     }
 
@@ -135,10 +136,12 @@ namespace Nitwork {
             callReceiveHandler(error.message());
             return;
         }
-        if (bytes_received < sizeof(struct header_s)) {
+        const auto packetSize = Zstd::getFrameContentSize(_receiveBuffer);
+        if (packetSize > MAX_PACKET_SIZE || packetSize < sizeof(struct header_s)) {
             callReceiveHandler("header not received");
             return;
         }
+        _receiveBuffer = Zstd::decompress(_receiveBuffer, bytes_received);
         // NOLINTBEGIN(cppcoreguidelines-pro-type-reinterpret-cast)
         auto *header = reinterpret_cast<struct header_s *>(_receiveBuffer.data());
         // NOLINTEND(cppcoreguidelines-pro-type-reinterpret-cast)

src/Nitwork/ANitwork.hpp

@@ -14,9 +14,9 @@
 #include <unordered_map>
 #include "INitwork.hpp"
 #include "Logger.hpp"
+#include "Zstd.hpp"
 
 namespace Nitwork {
-    constexpr int MAX_PACKET_SIZE = 1024;
 
     class ANitwork : public INitwork {
         public:
@@ -40,6 +40,7 @@ namespace Nitwork {
             void sendData(Packet &packet)
             {
                 n_id_t id = getPacketId(packet.endpoint);
+
                 if (packet.body.type() != typeid(T)) {
                     Logger::error("NITWORK: Invalid type");
                     return;
@@ -61,17 +62,18 @@ namespace Nitwork {
                         HEADER_CODE2};
                     data.header = newHeader;
                 }
+                std::vector<char> compressedPacket = Zstd::compress(data);
 
                 _socket.async_send_to(
-                    boost::asio::buffer(&data, sizeof(T)),
+                    boost::asio::buffer(compressedPacket),
                     packet.endpoint,
-                    [](const boost::system::error_code &error, std::size_t bytes_sent) {
+                    [compressedPacket](const boost::system::error_code &error, std::size_t bytes_sent) {
                         Logger::debug("NITWORK: Package sent");
                         if (error) {
                             Logger::error("NITWORK: " + std::string(error.message()));
                             return;
                         }
-                        if (bytes_sent != sizeof(T)) {
+                        if (bytes_sent != compressedPacket.size()) {
                             Logger::error("NITWORK: Package not sent");
                             return;
                         }

src/Nitwork/Zstd.hpp

@@ -0,0 +1,69 @@
+/*
+** EPITECH PROJECT, 2023
+** r-type
+** File description:
+** zstd
+*/
+
+#include <array>
+#include <stdexcept>
+#include <string>
+#include <zstd.h>
+
+namespace Nitwork {
+    constexpr int MAX_PACKET_SIZE   = 1024;
+    constexpr int COMPRESSION_LEVEL = 1;
+
+    class Zstd {
+        public:
+            template <typename T>
+            static std::vector<char> compress(const T &data)
+            {
+                if (!std::is_standard_layout_v<T> || !std::is_trivial_v<T>) {
+                    throw std::runtime_error("ZSTD: Data must be POD");
+                }
+                size_t const compressedSize = ZSTD_compressBound(sizeof(T));
+                std::vector<char> compressedData(compressedSize);
+                size_t const result = ZSTD_compress(
+                    compressedData.data(),
+                    compressedSize,
+                    reinterpret_cast<const char *>(&data),
+                    sizeof(T),
+                    COMPRESSION_LEVEL);
+
+                if (ZSTD_isError(result)) {
+                    throw std::runtime_error(
+                        std::string("ZSTD: Error while compressing: ") + ZSTD_getErrorName(result));
+                }
+                compressedData.resize(result);
+                return compressedData;
+            }
+
+            static std::array<char, MAX_PACKET_SIZE>
+            decompress(const std::array<char, MAX_PACKET_SIZE> &data, size_t size)
+            {
+                std::array<char, MAX_PACKET_SIZE> decompressedArray = {0};
+                size_t decompressedSize =
+                    ZSTD_decompress(decompressedArray.data(), MAX_PACKET_SIZE, data.data(), size);
+
+                if (ZSTD_isError(decompressedSize) != 0U) {
+                    throw std::runtime_error(
+                        std::string("ZSTD: Error while decompressing: ")
+                        + ZSTD_getErrorName(decompressedSize));
+                }
+                return decompressedArray;
+            }
+
+            static std::size_t getFrameContentSize(const std::array<char, MAX_PACKET_SIZE> &data)
+            {
+                std::size_t const frameContentSize = ZSTD_getFrameContentSize(data.data(), data.size());
+
+                if (ZSTD_isError(frameContentSize) != 0U) {
+                    throw std::runtime_error(
+                        std::string("ZSTD: Error while getting frame content size: ")
+                        + ZSTD_getErrorName(frameContentSize));
+                }
+                return frameContentSize;
+            }
+    };
+} // namespace Nitwork