Layer.h

Go to the documentation of this file.

#pragma once
 
#include <stdint.h>
#include <stdio.h>
#include "ProtocolType.h"
#include <string>
 
 
namespace pcpp
{
 
    class IDataContainer
    {
    public:
        virtual uint8_t* getDataPtr(size_t offset = 0) const = 0;
 
        virtual ~IDataContainer()
        {}
    };
 
    class Packet;
 
    class Layer : public IDataContainer
    {
        friend class Packet;
 
    public:
        virtual ~Layer();
 
        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
        {
            return (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);
    };
 
}  // namespace pcpp
 
inline std::ostream& operator<<(std::ostream& os, const pcpp::Layer& layer)
{
    os << layer.toString();
    return os;
}