Layer.h

Go to the documentation of this file.

#pragma once
 
#include <stdint.h>
#include <stdio.h>
#include "ProtocolType.h"
#include <ostream>
#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;
 
    namespace internal
    {
        struct LayerAllocationInfo
        {
            Packet* attachedPacket = nullptr;
 
            bool ownedByPacket = false;
 
            void attachPacket(Packet* packet, bool managed, bool force = false)
            {
                if (!force && attachedPacket != nullptr)
                {
                    throw std::runtime_error("Layer is already attached to a Packet");
                }
 
                attachedPacket = packet;
                ownedByPacket = managed;
            }
 
            void detach()
            {
                attachedPacket = nullptr;
                ownedByPacket = false;
            }
        };
    }  // namespace internal
 
    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_AllocationInfo.attachedPacket != nullptr;
        }
 
        void copyData(uint8_t* toArr) const;
 
        size_t copyData(uint8_t* dest, size_t destSize) 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;
        ProtocolType m_Protocol;
        Layer* m_NextLayer;
        Layer* m_PrevLayer;
 
    private:
        internal::LayerAllocationInfo m_AllocationInfo;
 
    protected:
        Layer() : m_Data(nullptr), m_DataLen(0), m_Protocol(UnknownProtocol), m_NextLayer(nullptr), m_PrevLayer(nullptr)
        {}
 
        Layer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet, ProtocolType protocol = UnknownProtocol)
            : m_Data(data), m_DataLen(dataLen), m_Protocol(protocol), m_NextLayer(nullptr), m_PrevLayer(prevLayer),
              m_AllocationInfo{ packet, false }
        {}
 
        // Copy c'tor
        Layer(const Layer& other);
        Layer& operator=(const Layer& other);
 
        Packet* getAttachedPacket()
        {
            return m_AllocationInfo.attachedPacket;
        }
 
        Packet const* getAttachedPacket() const
        {
            return m_AllocationInfo.attachedPacket;
        }
 
        void setNextLayer(Layer* nextLayer)
        {
            m_NextLayer = nextLayer;
        }
        void setPrevLayer(Layer* prevLayer)
        {
            m_PrevLayer = prevLayer;
        }
 
        // ------ Memory Control Methods -----
        // Used by derived classes to request buffer size changes.
 
        void allocData(size_t dataLen, bool zeroInit = true);
 
        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, Args&&... extraArgs)
        {
            return constructNextLayer<T>(data, dataLen, getAttachedPacket(), std::forward<Args>(extraArgs)...);
        }
 
        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 TFactory, typename... Args>
        Layer* constructNextLayerFromFactory(TFactory factoryFn, uint8_t* data, size_t dataLen, Args&&... extraArgs)
        {
            return constructNextLayerFromFactory<TFactory>(factoryFn, data, dataLen, getAttachedPacket(),
                                                           std::forward<Args>(extraArgs)...);
        }
 
        template <typename TFactory, typename... Args>
        Layer* constructNextLayerFromFactory(TFactory factoryFn, uint8_t* data, size_t dataLen, Packet* packet,
                                             Args&&... extraArgs)
        {
            if (hasNextLayer())
            {
                throw std::runtime_error("Next layer already exists");
            }
 
            // cppcheck-suppress redundantInitialization
            Layer* newLayer = factoryFn(data, dataLen, this, packet, std::forward<Args>(extraArgs)...);
            setNextLayer(newLayer);
            return newLayer;
        }
 
        template <typename T, typename... Args>
        Layer* tryConstructNextLayer(uint8_t* data, size_t dataLen, Args&&... extraArgs)
        {
            return tryConstructNextLayer<T>(data, dataLen, getAttachedPacket(), std::forward<Args>(extraArgs)...);
        }
 
        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;
        }
 
        template <typename T, typename TFallback, typename... Args>
        Layer* tryConstructNextLayerWithFallback(uint8_t* data, size_t dataLen, Args&&... extraArgs)
        {
            return tryConstructNextLayerWithFallback<T, TFallback>(data, dataLen, getAttachedPacket(),
                                                                   std::forward<Args>(extraArgs)...);
        }
 
        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 TFallback, typename TFactory, typename... Args>
        Layer* tryConstructNextLayerFromFactoryWithFallback(TFactory factoryFn, uint8_t* data, size_t dataLen,
                                                            Args&&... extraArgs)
        {
            // Note that the fallback is first to allow template argument deduction of the factory type.
            return tryConstructNextLayerFromFactoryWithFallback<TFallback, TFactory>(
                factoryFn, data, dataLen, getAttachedPacket(), std::forward<Args>(extraArgs)...);
        }
 
        template <typename TFallback, typename TFactory, typename... Args>
        Layer* tryConstructNextLayerFromFactoryWithFallback(TFactory factoryFn, uint8_t* data, size_t dataLen,
                                                            Packet* packet, Args&&... extraArgs)
        {
            auto nextLayer = constructNextLayerFromFactory<TFactory>(factoryFn, data, dataLen, packet,
                                                                     std::forward<Args>(extraArgs)...);
            if (nextLayer != nullptr)
            {
                return nextLayer;
            }
 
            // factory failed, construct fallback layer
            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);
        }
    };
 
    inline std::ostream& operator<<(std::ostream& os, const pcpp::Layer& layer)
    {
        os << layer.toString();
        return os;
    }
}  // namespace pcpp