NetworkMessages.hpp

Go to the documentation of this file.

/*
** EPITECH PROJECT, 2025
** Created by mael on 08/12/2025.
** File description:
** NetworkMessages.hpp
*/
 
#pragma once
 
#include <cstdint>
#include <stdexcept>
#include <string>
#include <vector>
 
namespace NetworkMessages {
 
    enum class MessageType : uint16_t {
        // Connection messages (0x00xx)
        HANDSHAKE_REQUEST = 0x0001,
        HANDSHAKE_RESPONSE = 0x0002,
        REGISTER_REQUEST = 0x0007,
        REGISTER_RESPONSE = 0x0008,
        LOGIN_REQUEST = 0x0009,
        LOGIN_RESPONSE = 0x000A,
        DISCONNECT = 0x0003,
        KICK = 0x0004,
        PING = 0x0005,
        PONG = 0x0006,
 
        // Client to Server gameplay messages (0x01xx)
        C2S_PLAYER_INPUT = 0x0100,
        C2S_JOIN_GAME = 0x0101,
 
        // Client to Server lobby messages (0x03xx)
        C2S_LIST_ROOMS = 0x0300,
        C2S_CREATE_ROOM = 0x0301,
        C2S_JOIN_ROOM = 0x0302,
        C2S_LEAVE_ROOM = 0x0306,
        C2S_AUTO_MATCHMAKING = 0x0308,     // Auto-matchmaking request (trigger matchmaking)
        C2S_UPDATE_AUTO_MM_PREF = 0x0309,  // Update auto-matchmaking preference only
        C2S_START_MATCHMAKING = 0x0303,
        C2S_CANCEL_MATCHMAKING = 0x0304,
        C2S_START_GAME = 0x0305,
        C2S_CHAT_MESSAGE = 0x0307,
 
        // Server to Client gameplay messages (0x02xx)
        S2C_GAME_STATE = 0x0200,
        S2C_GAME_START = 0x0201,
        S2C_ENTITY_DESTROYED = 0x0202,
        S2C_GAME_OVER = 0x0203,
        S2C_GAMERULE_UPDATE = 0x0204,
 
        // Server to Client lobby messages (0x04xx)
        S2C_ROOM_LIST = 0x0400,
        S2C_ROOM_CREATED = 0x0401,
        S2C_JOINED_ROOM = 0x0402,
        S2C_MATCHMAKING_STARTED = 0x0403,
        S2C_MATCH_FOUND = 0x0404,
        S2C_ROOM_STATE = 0x0405,
        S2C_CHAT_MESSAGE = 0x0406,
        S2C_LEFT_ROOM = 0x0407,
 
        UNKNOWN = 0xFFFF
    };
 
    // ============================================================================
    // LOW-LEVEL PROTOCOL FUNCTIONS (Generic)
    // ============================================================================
 
    inline std::vector<uint8_t> createMessage(MessageType type, const std::vector<uint8_t> &payload) {
        std::vector<uint8_t> packet;
 
        // Write message type (2 bytes, little endian)
        uint16_t typeValue = static_cast<uint16_t>(type);
        packet.push_back(static_cast<uint8_t>(typeValue & 0xFF));
        packet.push_back(static_cast<uint8_t>((typeValue >> 8) & 0xFF));
 
        // Write payload length (4 bytes, little endian)
        uint32_t length = static_cast<uint32_t>(payload.size());
        packet.push_back(static_cast<uint8_t>(length & 0xFF));
        packet.push_back(static_cast<uint8_t>((length >> 8) & 0xFF));
        packet.push_back(static_cast<uint8_t>((length >> 16) & 0xFF));
        packet.push_back(static_cast<uint8_t>((length >> 24) & 0xFF));
 
        // Write payload
        packet.insert(packet.end(), payload.begin(), payload.end());
 
        return packet;
    }
 
    inline MessageType getMessageType(const std::vector<uint8_t> &packet) {
        if (packet.size() < 6) {
            // Minimum: 2 (type) + 4 (length)
            return MessageType::UNKNOWN;
        }
 
        uint16_t typeValue = packet[0] | (packet[1] << 8);
        return static_cast<MessageType>(typeValue);
    }
 
    inline std::vector<uint8_t> getPayload(const std::vector<uint8_t> &packet) {
        if (packet.size() < 6) {
            return {};
        }
 
        // Read payload length
        uint32_t length = packet[2] | (packet[3] << 8) | (packet[4] << 16) | (packet[5] << 24);
 
        // Validate length is reasonable (max 10MB to prevent DoS attacks)
        constexpr uint32_t MAX_PAYLOAD_SIZE = 10 * 1024 * 1024;
        if (length > MAX_PAYLOAD_SIZE) {
            return {};
        }
 
        // Validate the declared length doesn't exceed actual packet size
        if (packet.size() < 6 + length) {
            return {};
        }
 
        // Additional sanity check: ensure no integer overflow when adding 6 + length
        if (length > packet.size() - 6) {
            return {};
        }
 
        return std::vector<uint8_t>(packet.begin() + 6, packet.begin() + 6 + length);
    }
 
    // ============================================================================
    // HIGH-LEVEL HELPER FUNCTIONS (Specific messages)
    // ============================================================================
 
    inline std::vector<uint8_t> serializeString(const std::string &str) {
        std::vector<uint8_t> bytes;
        uint32_t length = static_cast<uint32_t>(str.size());
 
        // Write length
        bytes.push_back(static_cast<uint8_t>(length & 0xFF));
        bytes.push_back(static_cast<uint8_t>((length >> 8) & 0xFF));
        bytes.push_back(static_cast<uint8_t>((length >> 16) & 0xFF));
        bytes.push_back(static_cast<uint8_t>((length >> 24) & 0xFF));
 
        // Write string data
        bytes.insert(bytes.end(), str.begin(), str.end());
 
        return bytes;
    }
 
    inline std::string deserializeString(const std::vector<uint8_t> &bytes, size_t &offset) {
        if (bytes.size() < offset + 4) {
            return "";
        }
 
        // Read length
        uint32_t length =
            bytes[offset] | (bytes[offset + 1] << 8) | (bytes[offset + 2] << 16) | (bytes[offset + 3] << 24);
 
        // Validate length is reasonable (max 1MB for strings to prevent DoS)
        constexpr uint32_t MAX_STRING_SIZE = 1024 * 1024;
        if (length > MAX_STRING_SIZE) {
            return "";
        }
 
        offset += 4;
 
        // Validate the declared length doesn't exceed actual buffer size
        if (bytes.size() < offset + length) {
            return "";
        }
 
        // Additional sanity check: ensure no integer overflow
        if (length > bytes.size() - offset) {
            return "";
        }
 
        std::string result(bytes.begin() + offset, bytes.begin() + offset + length);
        offset += length;
 
        return result;
    }
 
    // ============================================================================
    // CONNECTION MESSAGES
    // ============================================================================
 
    inline std::vector<uint8_t> createConnectRequest(const std::string &playerName,
                                                     bool isSpectator = false) {
        std::vector<uint8_t> payload = serializeString(playerName);
 
        // Add spectator flag (1 byte)
        payload.push_back(isSpectator ? 1 : 0);
 
        return createMessage(MessageType::HANDSHAKE_REQUEST, payload);
    }
 
    inline std::string parseConnectRequest(const std::vector<uint8_t> &packet, bool &isSpectator) {
        if (getMessageType(packet) != MessageType::HANDSHAKE_REQUEST) {
            isSpectator = false;
            return "";
        }
 
        auto payload = getPayload(packet);
        size_t offset = 0;
        std::string playerName = deserializeString(payload, offset);
 
        // Read spectator flag if present (backwards compatible)
        if (offset < payload.size()) {
            isSpectator = (payload[offset] != 0);
        } else {
            isSpectator = false;
        }
 
        return playerName;
    }
 
    inline std::string parseConnectRequest(const std::vector<uint8_t> &packet) {
        bool isSpectator = false;
        return parseConnectRequest(packet, isSpectator);
    }
 
    inline std::vector<uint8_t> createConnectResponse(const std::string &message) {
        auto payload = serializeString(message);
        return createMessage(MessageType::HANDSHAKE_RESPONSE, payload);
    }
 
    inline std::string parseConnectResponse(const std::vector<uint8_t> &packet) {
        if (getMessageType(packet) != MessageType::HANDSHAKE_RESPONSE) {
            return "";
        }
 
        auto payload = getPayload(packet);
        size_t offset = 0;
        return deserializeString(payload, offset);
    }
 
}  // namespace NetworkMessages