fixed GenerateAcceptKey (websocket protocol)

Author: usermicrodevices

build.sh

@@ -1,5 +1,4 @@
 #!/bin/bash
-# build.sh
 
 # Clone dependencies
 mkdir -p thirdparty

include/game/GameLogic.hpp

@@ -8,6 +8,7 @@
 #include <nlohmann/json.hpp>
 
 #include "network/PredictionSystem.hpp"
+#include "network/WebSocketProtocol.hpp"
 
 #include "game/LogicCore.hpp"
 #include "game/PlayerManager.hpp"

include/network/WebSocketProtocol.hpp

@@ -9,6 +9,7 @@
 #include <string>
 #include <sstream>
 #include <vector>
+#include <unordered_map>
 
 #include <zlib.h>
 #include <glm/glm.hpp>
@@ -34,6 +35,14 @@ namespace WebSocketProtocol {
         OP_PONG = 0xA
     };
 
+    static const std::unordered_map<std::string, int> IPCMessageTypes = {
+        {"welcome", 1},
+        {"heartbeat", 2},
+        {"broadcast", 3},
+        {"shutdown", 4},
+        {"reload_config", 5}
+    };
+
     // WebSocket frame structure
     struct WebSocketFrame {
         bool fin{true};

src/game/GameLogic.cpp

@@ -1104,25 +1104,36 @@ void GameLogic::PerformMaintenance() {
 void GameLogic::HandleIPCMessage(const nlohmann::json& message) {
     try {
         std::string msgType = message.value("type", "");
-        Logger::Debug("GameLogic handling IPC message type: {}", msgType);
-
-        if (msgType == "welcome") {
-            Logger::Info("Received welcome message from master: {}", message.value("message", ""));
-        } else if (msgType == "heartbeat") {
-            // Handle heartbeat from master
-            int count = message.value("count", 0);
-            Logger::Debug("Received heartbeat #{} from master", count);
-        } else if (msgType == "broadcast") {
-            // Broadcast message to all players
-            if (message.contains("data")) {
-                BroadcastToAllPlayers(message["data"]);
-            }
-        } else if (msgType == "shutdown") {
-            Logger::Info("Received shutdown command from master");
-            Shutdown();
-        } else if (msgType == "reload_config") {
-            Logger::Info("Received config reload command from master");
-            // Reload configuration if needed
+        auto it = WebSocketProtocol::IPCMessageTypes.find(msgType);
+        if (it == WebSocketProtocol::IPCMessageTypes.end()) {
+            Logger::Warn("Unknown IPC message type: {}", msgType);
+            return;
+        }
+        int typeCode = it->second;
+        switch (typeCode) {
+            case 1: // welcome
+                //Logger::Info("Received welcome message from master: {}", message.value("message", ""));
+                break;
+            case 2: // heartbeat
+                //int count = message.value("count", 0);
+                //Logger::Debug("Received heartbeat #{} from master", count);
+                break;
+            case 3: // broadcast
+                if (message.contains("data")) {
+                    BroadcastToAllPlayers(message["data"]);
+                }
+                break;
+            case 4: // shutdown
+                Logger::Info("Received shutdown command from master");
+                Shutdown();
+                break;
+            case 5: // reload_config
+                Logger::Info("Received config reload command from master");
+                // TODO: Reload configuration if needed
+                break;
+            default:
+                Logger::Warn("Unhandled IPC message code: {}", typeCode);
+                break;
         }
     } catch (const std::exception& e) {
         Logger::Error("Error handling IPC message: {}", e.what());
@@ -1144,7 +1155,7 @@ void GameLogic::BroadcastToAllPlayers(const nlohmann::json& message) {
         auto sessions = connectionManager_->GetAllSessions();
 
         if (sessions.empty()) {
-            Logger::Debug("No active sessions to broadcast to");
+            //Logger::Debug("No active sessions to broadcast to");
             return;
         }
 
@@ -1180,7 +1191,7 @@ void GameLogic::BroadcastToAllPlayersBinary(uint16_t messageType, const std::vec
         auto sessions = connectionManager_->GetAllSessions();
 
         if (sessions.empty()) {
-            Logger::Debug("No active sessions to broadcast binary to");
+            //Logger::Debug("No active sessions to broadcast binary to");
             return;
         }
 

src/main.cpp

@@ -219,7 +219,7 @@ void WorkerMain(int workerId, const WorkerGroupConfig& groupConfig, ProcessPool*
                             try {
                                 // Parse JSON message
                                 auto jsonMsg = nlohmann::json::parse(message);
-                                Logger::Debug("Worker {} received IPC message: {}", workerId, jsonMsg.dump());
+                                //Logger::Debug("Worker {} received IPC message: {}", workerId, jsonMsg.dump());
 
                                 // Handle IPC message in game logic
                                 gameLogic.HandleIPCMessage(jsonMsg);

src/network/WebSocketProtocol.cpp

@@ -1176,31 +1176,40 @@ std::string GenerateWebSocketKey() {
 std::string GenerateAcceptKey(const std::string& key) {
     const std::string magic_guid = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
     std::string combined = key + magic_guid;
-
-    unsigned char hash[SHA_DIGEST_LENGTH];
+    unsigned char hash[SHA_DIGEST_LENGTH]; // 20 bytes
     SHA1(reinterpret_cast<const unsigned char*>(combined.c_str()), combined.size(), hash);
 
-    // Base64 encode
+    // Base64 encode according to RFC 4648
     const std::string base64_chars =
-        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 
     std::string result;
     int i = 0;
-    while (i < SHA_DIGEST_LENGTH) {
-        uint32_t octet_a = i < SHA_DIGEST_LENGTH ? hash[i++] : 0;
-        uint32_t octet_b = i < SHA_DIGEST_LENGTH ? hash[i++] : 0;
-        uint32_t octet_c = i < SHA_DIGEST_LENGTH ? hash[i++] : 0;
-
-        uint32_t triple = (octet_a << 16) + (octet_b << 8) + octet_c;
 
+    // Process full 3‑byte groups
+    while (i < SHA_DIGEST_LENGTH - 2) {
+        uint32_t triple = (hash[i] << 16) | (hash[i+1] << 8) | hash[i+2];
         result += base64_chars[(triple >> 18) & 0x3F];
         result += base64_chars[(triple >> 12) & 0x3F];
         result += base64_chars[(triple >> 6) & 0x3F];
         result += base64_chars[triple & 0x3F];
+        i += 3;
     }
 
-    // Remove padding
-    result = result.substr(0, 28);
+    // Handle remaining bytes with correct padding
+    int remaining = SHA_DIGEST_LENGTH - i;
+    if (remaining == 1) {
+        uint32_t triple = (hash[i] << 16);
+        result += base64_chars[(triple >> 18) & 0x3F];
+        result += base64_chars[(triple >> 12) & 0x3F];
+        result += "==";
+    } else if (remaining == 2) {
+        uint32_t triple = (hash[i] << 16) | (hash[i+1] << 8);
+        result += base64_chars[(triple >> 18) & 0x3F];
+        result += base64_chars[(triple >> 12) & 0x3F];
+        result += base64_chars[(triple >> 6) & 0x3F];
+        result += "=";
+    }
 
     return result;
 }

src/process/ProcessPool.cpp

@@ -466,7 +466,7 @@ bool ProcessPool::SendToWorker(int workerId, const std::string& message) {
         Logger::Error("Failed to send message content to worker {}", workerId);
         return false;
     }
-    Logger::Debug("Sent {} bytes to worker {}", message.length(), workerId);
+    //Logger::Debug("Sent {} bytes to worker {}", message.length(), workerId);
     return true;
 }
 
@@ -500,7 +500,7 @@ std::string ProcessPool::ReceiveFromMaster() {
     }
     buffer[msg_len] = '\0';
     std::string message(buffer.data(), msg_len);
-    Logger::Debug("Received {} bytes from master", msg_len);
+    //Logger::Debug("Received {} bytes from master", msg_len);
     return message;
 }