TpktLayer.h

Go to the documentation of this file.

#pragma once
 
#include "EthLayer.h"
#include "Layer.h"
 
 
namespace pcpp
{
#pragma pack(push, 1)
    struct tpkthdr
    {
        uint8_t version;
        uint8_t reserved;
        uint16_t length;
    };
#pragma pack(pop)
    static_assert(sizeof(tpkthdr) == 4, "tpkthdr size is not 4 bytes");
 
    class TpktLayer : public Layer
    {
    public:
        TpktLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : Layer(data, dataLen, prevLayer, packet, TPKT)
        {}
 
        TpktLayer(uint8_t version, uint16_t length);
 
        ~TpktLayer() override = default;
 
        uint8_t getReserved() const;
 
        uint8_t getVersion() const;
 
        uint16_t getLength() const;
 
        void setVersion(uint8_t version) const;
 
        void setLength(uint16_t length) const;
 
        size_t getHeaderLen() const override
        {
            return sizeof(tpkthdr);
        }
 
        void computeCalculateFields() override
        {}
 
        void parseNextLayer() override;
 
        static bool isTpktPort(uint16_t portSrc, uint16_t portDst)
        {
            return portSrc == 102 || portDst == 102;
        }
 
        static bool isDataValid(const uint8_t* data, size_t dataSize)
        {
            return canReinterpretAs<tpkthdr>(data, dataSize);
        }
 
        std::string toString() const override;
 
        OsiModelLayer getOsiModelLayer() const override
        {
            return OsiModelTransportLayer;
        }
 
        struct SerializedFields : Layer::SerializedFields
        {
            static std::vector<FieldDescriptor> all()
            {
                auto result = Layer::SerializedFields::all();
                std::initializer_list<FieldDescriptor> extra{ Version };
                std::copy(extra.begin(), extra.end(), std::back_inserter(result));
                return result;
            }
 
            static const FieldDescriptor Version;
        };
 
    protected:
        void serializeLayer(ObjectScope& serializer) const override;
 
    private:
        tpkthdr* getTpktHeader() const
        {
            return reinterpret_cast<tpkthdr*>(m_Data);
        }
    };
 
}  // namespace pcpp