Layer.h

Go to the documentation of this file.

#ifndef PACKETPP_LAYER
#define PACKETPP_LAYER
 
#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; }
 
        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 != NULL; }
 
        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(NULL), m_DataLen(0), m_Packet(NULL), m_Protocol(UnknownProtocol), m_NextLayer(NULL), m_PrevLayer(NULL), m_IsAllocatedInPacket(false) { }
 
        Layer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet) :
            m_Data(data), m_DataLen(dataLen),
            m_Packet(packet), m_Protocol(UnknownProtocol),
            m_NextLayer(NULL), 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
 
#endif /* PACKETPP_LAYER */