Better message transmission

.gitmodules

@@ -21,3 +21,6 @@
 [submodule "deps/flatbuffers"]
 	path = deps/flatbuffers
 	url = https://github.com/google/flatbuffers.git
+[submodule "deps/base64"]
+	path = deps/base64
+	url = https://github.com/tobiaslocker/base64.git

deps/CMakeLists.txt

@@ -3,6 +3,11 @@ add_subdirectory(unicorn)
 
 ##########################################
 
+option(BASE64_ENABLE_TESTING "" OFF)
+add_subdirectory(base64)
+
+##########################################
+
 option(FLATBUFFERS_BUILD_TESTS "" OFF)
 option(FLATBUFFERS_INSTALL "" OFF)
 add_subdirectory(flatbuffers)

page/public/emulator-worker.js

@@ -43,10 +43,10 @@ function handleMessage(message) {
 }
 
 function getMessageFromQueue() {
-  if(msgQueue.length == 0){
+  if (msgQueue.length == 0) {
     return "";
   }
-  
+
   return msgQueue.pop();
 }
 

src/.clang-format-ignore

@@ -0,0 +1 @@
+**/*.hxx

src/debugger/CMakeLists.txt

@@ -17,6 +17,7 @@ endif()
 target_link_libraries(debugger PRIVATE
   windows-emulator
   flatbuffers
+  base64
 )
 
 set_property(GLOBAL PROPERTY VS_STARTUP_PROJECT debugger)

src/debugger/event_handler.cpp

@@ -1,21 +1,54 @@
 #include "event_handler.hpp"
+#include "message_transmitter.hpp"
+
+#include <base64.hpp>
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4244)
+#endif
+
 #include "events_generated.hxx"
 
-#include "message_transmitter.hpp"
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
 
 namespace debugger
 {
     namespace
     {
-        void handle_event(event_context& c, const event& e, const nlohmann::json& obj)
+        std::optional<Debugger::DebugEventT> receive_event()
         {
-            switch (e.type)
+            const auto message = receive_message();
+            if (message.empty())
             {
-            case event_type::pause:
+                return std::nullopt;
+            }
+
+            const auto data = base64::from_base64(message);
+
+            flatbuffers::Verifier verifier(reinterpret_cast<const uint8_t*>(data.data()), data.size());
+            if (!Debugger::VerifyDebugEventBuffer(verifier))
+            {
+                return std::nullopt;
+            }
+
+            Debugger::DebugEventT e{};
+            Debugger::GetDebugEvent(data.data())->UnPackTo(&e);
+
+            return {std::move(e)};
+        }
+
+        void handle_event(event_context& c, const Debugger::DebugEventT& e)
+        {
+            switch (e.event.type)
+            {
+            case Debugger::Event_PauseEvent:
                 c.win_emu.emu().stop();
                 break;
 
-            case event_type::run:
+            case Debugger::Event_RunEvent:
                 c.resume = true;
                 break;
 
@@ -23,19 +56,6 @@ namespace debugger
                 break;
             }
         }
-
-        void handle_object(event_context& c, const nlohmann::json& obj)
-        {
-            try
-            {
-                const auto e = obj.get<event>();
-                handle_event(c, e, obj);
-            }
-            catch (const std::exception& e)
-            {
-                puts(e.what());
-            }
-        }
     }
 
     void handle_events(event_context& c)
@@ -44,13 +64,13 @@ namespace debugger
         {
             suspend_execution(0ms);
 
-            const auto obj = receive_object();
-            if (obj.is_null())
+            const auto e = receive_event();
+            if (!e.has_value())
             {
                 break;
             }
 
-            handle_object(c, obj);
+            handle_event(c, *e);
         }
     }
 }

src/debugger/main.cpp

@@ -4,8 +4,6 @@
 #include <cstdio>
 #include "event_handler.hpp"
 
-#include <utils/finally.hpp>
-
 namespace
 {
     bool run_emulation(windows_emulator& win_emu)

src/debugger/message_transmitter.cpp

@@ -1,31 +1,34 @@
 #include "message_transmitter.hpp"
 #include <platform/compiler.hpp>
 
+#include <thread>
+
+#include <utils/finally.hpp>
 #ifdef OS_EMSCRIPTEN
 #include <emscripten.h>
 #endif
 
+using namespace std::literals;
+
 namespace debugger
 {
-    namespace
+    void send_message(const std::string& message)
     {
-        void send_message(const std::string& message)
-        {
 #ifdef OS_EMSCRIPTEN
-            // clang-format off
+        // clang-format off
         EM_ASM_({
                 handleMessage(UTF8ToString($0));
         }, message.c_str());
-            // clang-format on
+        // clang-format on
 #else
-            (void)message;
+        (void)message;
 #endif
-        }
+    }
 
-        std::string receive_message()
-        {
+    std::string receive_message()
+    {
 #ifdef OS_EMSCRIPTEN
-            // clang-format off
+        // clang-format off
         auto* ptr = EM_ASM_PTR({
             var message = getMessageFromQueue();
             if (!message || message.length == 0)
@@ -38,54 +41,36 @@ namespace debugger
             stringToUTF8(message, buffer, length);
             return buffer;
         });
-            // clang-format on
+        // clang-format on
 
-            if (!ptr)
-            {
-                return {};
-            }
-
-            const auto _ = utils::finally([&] {
-                free(ptr); //
-            });
-
-            return {reinterpret_cast<const char*>(ptr)};
-#else
+        if (!ptr)
+        {
             return {};
-#endif
         }
 
-        void send_object(const nlohmann::json& json)
-        {
-            const std::string res = json.dump();
-            send_message(res);
-        }
+        const auto _ = utils::finally([&] {
+            free(ptr); //
+        });
 
-        nlohmann::json receive_object()
-        {
-            auto message = receive_message();
-            if (message.empty())
-            {
-                return {};
-            }
-
-            return nlohmann::json::parse(message);
-        }
-
-        void suspend_execution(const std::chrono::milliseconds ms)
-        {
-#ifdef OS_EMSCRIPTEN
-            emscripten_sleep(static_cast<uint32_t>(ms.count()));
+        return {reinterpret_cast<const char*>(ptr)};
 #else
-            if (ms > 0ms)
-            {
-                std::this_thread::sleep_for(ms);
-            }
-            else
-            {
-                std::this_thread::yield();
-            }
+        return {};
 #endif
-        }
     }
-    }
+
+    void suspend_execution(const std::chrono::milliseconds ms)
+    {
+#ifdef OS_EMSCRIPTEN
+        emscripten_sleep(static_cast<uint32_t>(ms.count()));
+#else
+        if (ms > 0ms)
+        {
+            std::this_thread::sleep_for(ms);
+        }
+        else
+        {
+            std::this_thread::yield();
+        }
+#endif
+    }
+}

src/debugger/message_transmitter.hpp

@@ -1,10 +1,11 @@
 #pragma once
 
-#include <nlohmann/json.hpp>
+#include <chrono>
+#include <string>
 
 namespace debugger
 {
-    void suspend_execution(const std::chrono::milliseconds ms = 0ms);
-    void send_object(const nlohmann::json& json);
-    nlohmann::json receive_object();
+    void suspend_execution(std::chrono::milliseconds ms = std::chrono::milliseconds(0));
+    void send_message(const std::string& message);
+    std::string receive_message();
 }