Server/SourceFiles/Core/Network/Packages/Packet.cpp - master - Shymer123/LumenServer

Server/SourceFiles/Core/Network/Packages/Packet.cpp
129 строк5 KB
Shymer123
Initial commit: LumenServer
20 июн 2026, 12:43
20 июн 2026, 12:43173f14c
#include "Packet.h"
#include <arpa/inet.h>

namespace Core::Network::Packages {

    PacketHeader::PacketHeader(Core::Network::Packages::MessageType type, uint32_t length)
        : type(type), payloadLength(length)
    {}

    void PacketHeader::serialize(std::byte* buffer) const
    {
        buffer[0] = static_cast<std::byte>(static_cast<uint8_t>(type));

        uint32_t networkOrder = htonl(payloadLength);
        std::memcpy(buffer + 1, &networkOrder, sizeof(uint32_t));
    }

    PacketHeader PacketHeader::deserialize(const std::byte* buffer)
    {
        PacketHeader hdr;
        hdr.type = static_cast<Core::Network::Packages::MessageType>(static_cast<uint8_t>(buffer[0]));

        uint32_t networkOrder;
        std::memcpy(&networkOrder, buffer + 1, sizeof(uint32_t));
        hdr.payloadLength = ntohl(networkOrder);

        return hdr;
    }

    void FileMetaHeader::serialize(std::byte* buffer) const
    {
        uint32_t networkJsonLength = htonl(jsonMetaLength);
        uint32_t networkFileLength = htonl(fileDataLength);

        std::memcpy(buffer, &networkJsonLength, sizeof(uint32_t));
        std::memcpy(buffer + sizeof(uint32_t), &networkFileLength, sizeof(uint32_t));
    }

    FileMetaHeader FileMetaHeader::deserialize(const std::byte* buffer)
    {
        FileMetaHeader meta;

        uint32_t networkJsonLength, networkFileLength;
        std::memcpy(&networkJsonLength, buffer, sizeof(uint32_t));
        std::memcpy(&networkFileLength, buffer + sizeof(uint32_t), sizeof(uint32_t));

        meta.jsonMetaLength = ntohl(networkJsonLength);
        meta.fileDataLength = ntohl(networkFileLength);

        return meta;
    }

    Packet::Packet(Core::Network::Packages::MessageType type, const std::vector<std::byte>& data)
        : header(type, static_cast<uint32_t>(data.size())), payload(data)
    {}

    Packet::Packet(const std::vector<std::byte>& jsonMeta, const std::vector<std::byte>& fileData)
    {
        header.type = MessageType::FILE;

        FileMetaHeader meta;
        meta.jsonMetaLength = static_cast<uint32_t>(jsonMeta.size());
        meta.fileDataLength = static_cast<uint32_t>(fileData.size());

        payload.resize(FileMetaHeader::SIZE + jsonMeta.size());
        meta.serialize(payload.data());
        std::memcpy(payload.data() + FileMetaHeader::SIZE, jsonMeta.data(), jsonMeta.size());

        this->fileData = fileData;

        header.payloadLength = static_cast<uint32_t>(payload.size());
    }

    std::vector<std::byte> Packet::serialize() const
    {
        if(header.type == MessageType::JSON)
        {
            std::vector<std::byte> buf(PacketHeader::SIZE + payload.size());
            header.serialize(buf.data());
            std::memcpy(buf.data() + PacketHeader::SIZE, payload.data(), payload.size());
            return buf;
        }
        else if(header.type == MessageType::FILE)
        {
            std::vector<std::byte> buf(PacketHeader::SIZE + payload.size() + fileData.size());
            header.serialize(buf.data());
            std::memcpy(buf.data() + PacketHeader::SIZE, payload.data(), payload.size());
            std::memcpy(buf.data() + PacketHeader::SIZE + payload.size(), fileData.data(), fileData.size());
            return buf;
        }

        return {};
    }

    Packet Packet::fromRaw(const PacketHeader& header, std::vector<std::byte>&& payload)
    {
        Packet packet;
        packet.header = header;

        if(header.type == MessageType::JSON)
        {
            packet.payload = std::move(payload);
        }
        else if(header.type == MessageType::FILE)
        {
           if(payload.size() >= FileMetaHeader::SIZE)
           {
               FileMetaHeader meta = FileMetaHeader::deserialize(payload.data());

               if(payload.size() >= FileMetaHeader::SIZE + meta.jsonMetaLength)
               {
                   std::vector<std::byte> jsonMeta(meta.jsonMetaLength);
                   std::memcpy(jsonMeta.data(), payload.data() + FileMetaHeader::SIZE, meta.jsonMetaLength);

                   packet.payload = std::move(jsonMeta);

                   if(payload.size() > FileMetaHeader::SIZE + meta.jsonMetaLength)
                   {
                       size_t fileDataStart = FileMetaHeader::SIZE + meta.jsonMetaLength;
                       packet.fileData.resize(meta.fileDataLength);
                       std::memcpy(packet.fileData.data(), payload.data() + fileDataStart, meta.fileDataLength);
                   }
               }
           }
        }
        return packet;
    }

} // namespace Core::Network::Packages