Layer.h

Go to the documentation of this file.

#pragma once
 
#include <stdint.h>
#include <stdio.h>
#include "ProtocolType.h"
#include <string>
#include <stdexcept>
#include <utility>
 
 
namespace pcpp
{
 
    class IDataContainer
    {
    public:
        virtual uint8_t* getDataPtr(size_t offset = 0) const = 0;
 
        virtual ~IDataContainer() = default;
    };
 
    class Packet;
 
    class Layer : public IDataContainer
    {
        friend class Packet;
 
    public:
        ~Layer() override;
 
        Layer* getNextLayer() const
        {
            return m_NextLayer;
        }
 
        Layer* getPrevLayer() const
        {
            return m_PrevLayer;
        }
 
        ProtocolType getProtocol() const
        {
            return m_Protocol;
        }
 
        bool isMemberOfProtocolFamily(ProtocolTypeFamily protocolTypeFamily) const;
 
        uint8_t* getData() const
        {
            return m_Data;
        }
 
        size_t getDataLen() const
        {
            return m_DataLen;
        }
 
        uint8_t* getLayerPayload() const
        {
            return m_Data + getHeaderLen();
        }
 
        size_t getLayerPayloadSize() const
        {
            return m_DataLen - getHeaderLen();
        }
 
        bool isAllocatedToPacket() const
        {
            return m_Packet != nullptr;
        }
 
        void copyData(uint8_t* toArr) const;
 
        // implement abstract methods
 
        uint8_t* getDataPtr(size_t offset = 0) const override
        {
            return static_cast<uint8_t*>(m_Data + offset);
        }
 
        // abstract methods
 
        virtual void parseNextLayer() = 0;
 
        virtual size_t getHeaderLen() const = 0;
 
        virtual void computeCalculateFields() = 0;
 
        virtual std::string toString() const = 0;
 
        virtual OsiModelLayer getOsiModelLayer() const = 0;
 
    protected:
        uint8_t* m_Data;
        size_t m_DataLen;
        Packet* m_Packet;
        ProtocolType m_Protocol;
        Layer* m_NextLayer;
        Layer* m_PrevLayer;
        bool m_IsAllocatedInPacket;
 
        Layer()
            : m_Data(nullptr), m_DataLen(0), m_Packet(nullptr), m_Protocol(UnknownProtocol), m_NextLayer(nullptr),
              m_PrevLayer(nullptr), m_IsAllocatedInPacket(false)
        {}
 
        Layer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet, ProtocolType protocol = UnknownProtocol)
            : m_Data(data), m_DataLen(dataLen), m_Packet(packet), m_Protocol(protocol), m_NextLayer(nullptr),
              m_PrevLayer(prevLayer), m_IsAllocatedInPacket(false)
        {}
 
        // Copy c'tor
        Layer(const Layer& other);
        Layer& operator=(const Layer& other);
 
        void setNextLayer(Layer* nextLayer)
        {
            m_NextLayer = nextLayer;
        }
        void setPrevLayer(Layer* prevLayer)
        {
            m_PrevLayer = prevLayer;
        }
 
        virtual bool extendLayer(int offsetInLayer, size_t numOfBytesToExtend);
        virtual bool shortenLayer(int offsetInLayer, size_t numOfBytesToShorten);
 
        bool hasNextLayer() const
        {
            return m_NextLayer != nullptr;
        }
 
        template <typename T, typename... Args>
        Layer* constructNextLayer(uint8_t* data, size_t dataLen, Packet* packet, Args&&... extraArgs)
        {
            if (hasNextLayer())
            {
                throw std::runtime_error("Next layer already exists");
            }
 
            Layer* newLayer = new T(data, dataLen, this, packet, std::forward<Args>(extraArgs)...);
            setNextLayer(newLayer);
            return newLayer;
        }
 
        template <typename T, typename TFallback, typename... Args>
        Layer* tryConstructNextLayerWithFallback(uint8_t* data, size_t dataLen, Packet* packet, Args&&... extraArgs)
        {
            if (tryConstructNextLayer<T>(data, dataLen, packet, std::forward<Args>(extraArgs)...))
            {
                return m_NextLayer;
            }
 
            return constructNextLayer<TFallback>(data, dataLen, packet);
        }
 
        template <typename T> static bool canReinterpretAs(const uint8_t* data, size_t dataLen)
        {
            return data != nullptr && dataLen >= sizeof(T);
        }
 
    private:
        template <typename T, typename... Args>
        Layer* tryConstructNextLayer(uint8_t* data, size_t dataLen, Packet* packet, Args&&... extraArgs)
        {
            if (T::isDataValid(data, dataLen))
            {
                return constructNextLayer<T>(data, dataLen, packet, std::forward<Args>(extraArgs)...);
            }
            return nullptr;
        }
    };
 
    inline std::ostream& operator<<(std::ostream& os, const pcpp::Layer& layer)
    {
        os << layer.toString();
        return os;
    }
}  // namespace pcpp