packet_filter.h

Go to the documentation of this file.

#pragma once

#include <array>
#include <vector>
#include <cstdint>
#include <cstring>

#include "memory.h"

BEGIN_NAMESPACE_MEMORY

template <typename T, std::size_t BufferSize, std::size_t HeaderLength>
class PacketFilter
{
public:
    PacketFilter();

    virtual void clear();

    const std::vector<T>& filter(const uint8_t* data, std::size_t size);

protected:
    virtual bool isHeader(const uint8_t* data, std::size_t size) = 0;

    virtual std::size_t findEnd(const uint8_t* start, std::size_t size) = 0;

   virtual T convertToPacket(const uint8_t* start, std::size_t size) = 0;


private:
    std::array<uint8_t, BufferSize> buffer;
    std::size_t fillSize;
    std::vector<T> packets;

    
    std::pair<std::size_t, std::size_t> findPacket(const uint8_t* data, std::size_t size);
    void removeFromBeginning(std::size_t size);
    void findPackets();

};

template <typename T, std::size_t BufferSize, std::size_t HeaderLength>
PacketFilter<T, BufferSize, HeaderLength>::PacketFilter()
    : fillSize(0)
{
    static_assert(BufferSize > HeaderLength, "BufferSize must be greater than HeaderLength");
}

template <typename T, std::size_t BufferSize, std::size_t HeaderLength>
void PacketFilter<T, BufferSize, HeaderLength>::clear()
{
    fillSize = 0;
}

template <typename T, std::size_t BufferSize, std::size_t HeaderLength>
const std::vector<T>& PacketFilter<T, BufferSize, HeaderLength>::filter(const uint8_t* data, std::size_t size)
{
    packets.clear();

    std::size_t copySize = 0;
    while (copySize != size)
    {
        std::size_t remaining = BufferSize - fillSize;
        if (size - copySize <= remaining)
        {
            std::memcpy(buffer.data() + fillSize, data + copySize, size - copySize);
            fillSize += size - copySize;
            copySize = size;
        }
        else
        {
            std::memcpy(buffer.data() + fillSize, data + copySize, remaining);
            fillSize = BufferSize;
            copySize += remaining;
        }

        findPackets();

        // With full buffer header is found but no complete packet
        if (fillSize == BufferSize)
            removeFromBeginning(HeaderLength);
    }
    return packets;
}

template <typename T, std::size_t BufferSize, std::size_t HeaderLength>
inline std::pair<std::size_t, std::size_t> PacketFilter<T, BufferSize, HeaderLength>::findPacket(const uint8_t* data, std::size_t size)
{
    std::pair<std::size_t, std::size_t> result(std::string::npos, std::string::npos);

    if (size < HeaderLength)
        return result;

    for (std::size_t i = 0; i < size - HeaderLength; i++)
    {
        if (isHeader(data + i, size - i))
        {
            result.first = i;
            break;
        }
    }

    if (result.first != std::string::npos)
    {
        std::size_t end = findEnd(data + result.first, size - result.first);
        if (end != std::string::npos)
            result.second = result.first + end;
    }
    return result;
}

template <typename T, std::size_t BufferSize, std::size_t HeaderLength>
void PacketFilter<T, BufferSize, HeaderLength>::removeFromBeginning(std::size_t size)
{
    if (size >= fillSize)
    {
        fillSize = 0;
    }
    else
    {
        std::memmove(buffer.data(), buffer.data() + size, fillSize - size);
        fillSize -= size;
    }
}

template <typename T, std::size_t BufferSize, std::size_t HeaderLength>
void PacketFilter<T, BufferSize, HeaderLength>::findPackets()
{
    std::pair<std::size_t, std::size_t> packetInds = findPacket(buffer.data(), fillSize);
    if (packetInds.first != std::string::npos && packetInds.second != std::string::npos)
    {
        packets.emplace_back(convertToPacket(buffer.data() + packetInds.first, packetInds.second - packetInds.first + 1));
        removeFromBeginning(packetInds.second + 1);
        findPackets();
    }
    else if (packetInds.first != std::string::npos)
    {
        removeFromBeginning(packetInds.first);
    }
    else
    {
        removeFromBeginning(fillSize - HeaderLength);
    }
}

END_NAMESPACE_MEMORY