TLVData.h

Go to the documentation of this file.

#ifndef PACKETPP_TLV_DATA
#define PACKETPP_TLV_DATA

#include "Layer.h"
#include "IpAddress.h"
#include <string.h>


namespace pcpp
{
    class TLVRecord
    {
    protected:

        struct TLVRawData
        {
            uint8_t recordType;
            uint8_t recordLen;
            uint8_t recordValue[];
        };

        TLVRawData* m_Data;

    public:

        TLVRecord(uint8_t* recordRawData)
        {
            if (recordRawData == NULL)
                m_Data = NULL;
            else
                m_Data = (TLVRawData*)recordRawData;
        }

        TLVRecord(const TLVRecord& other)
        {
            m_Data = other.m_Data;
        }

        virtual ~TLVRecord() { }

        TLVRecord& operator=(const TLVRecord& other)
        {
            m_Data = other.m_Data;
            return *this;
        }

        bool operator==(const TLVRecord& rhs)
        {
            if (m_Data == rhs.m_Data)
                return true;

            if (getTotalSize() != rhs.getTotalSize())
                return false;

            if (isNull() || ((TLVRecord&)rhs).isNull())
                return false;

            return (memcmp(m_Data, rhs.m_Data, getTotalSize()) == 0);
        }


        uint8_t getType() { return m_Data->recordType; }

        uint8_t* getValue() { return m_Data->recordValue; }

        bool isNull() { return (m_Data == NULL); }

        bool isNotNull() { return (m_Data != NULL); }

        uint8_t* getRecordBasePtr() { return (uint8_t*)m_Data; }

        void purgeRecordData() { if (!isNull()) delete [] m_Data; }

        template<typename T>
        T getValueAs(size_t offset = 0)
        {
            if (getDataSize() - offset < sizeof(T))
                return 0;

            T result;
            memcpy(&result, m_Data->recordValue + offset, sizeof(T));
            return result;
        }

        template<typename T>
        bool setValue(T newValue, int valueOffset = 0)
        {
            if (getDataSize() < sizeof(T))
                return false;

            memcpy(m_Data->recordValue + valueOffset, &newValue, sizeof(T));
            return true;
        }

        virtual size_t getTotalSize() const = 0;

        virtual size_t getDataSize() = 0;

    };


    template<typename TLVRecordType>
    class TLVRecordReader
    {
    private:
        size_t m_RecordCount;

    public:

        TLVRecordReader() { m_RecordCount = (size_t)-1; }

        TLVRecordReader(const TLVRecordReader& other)
        {
            m_RecordCount = other.m_RecordCount;
        }

        virtual ~TLVRecordReader() { }

        TLVRecordReader& operator=(const TLVRecordReader& other)
        {
            m_RecordCount = other.m_RecordCount;
            return *this;
        }

        TLVRecordType getFirstTLVRecord(uint8_t* tlvDataBasePtr, size_t tlvDataLen)
        {
            // check if there are records at all
            if (tlvDataLen == 0)
                return TLVRecordType(NULL);

            return TLVRecordType(tlvDataBasePtr);
        }

        TLVRecordType getNextTLVRecord(TLVRecordType& record, uint8_t* tlvDataBasePtr, size_t tlvDataLen)
        {
            if (record.isNull())
                return TLVRecordType(NULL);

            // record pointer is out-bounds of the TLV records memory
            if ((record.getRecordBasePtr() - tlvDataBasePtr) < 0)
                return TLVRecordType(NULL);

            // record pointer is out-bounds of the TLV records memory
            if (record.getRecordBasePtr() - tlvDataBasePtr + (int)record.getTotalSize()  >= (int)tlvDataLen)
                return TLVRecordType(NULL);

            return TLVRecordType(record.getRecordBasePtr() + record.getTotalSize());
        }

        TLVRecordType getTLVRecord(uint8_t recordType, uint8_t* tlvDataBasePtr, size_t tlvDataLen)
        {
            TLVRecordType curRec = getFirstTLVRecord(tlvDataBasePtr, tlvDataLen);
            while (!curRec.isNull())
            {
                if (curRec.getType() == recordType)
                    return curRec;

                curRec = getNextTLVRecord(curRec, tlvDataBasePtr, tlvDataLen);
            }

            return TLVRecordType(NULL);
        }

        size_t getTLVRecordCount(uint8_t* tlvDataBasePtr, size_t tlvDataLen)
        {
            if (m_RecordCount != (size_t)-1)
                return m_RecordCount;

            m_RecordCount = 0;
            TLVRecordType curRec = getFirstTLVRecord(tlvDataBasePtr, tlvDataLen);
            while (!curRec.isNull())
            {
                m_RecordCount++;
                curRec = getNextTLVRecord(curRec, tlvDataBasePtr, tlvDataLen);
            }

            return m_RecordCount;
        }

        void changeTLVRecordCount(int changedBy) { if (m_RecordCount != (size_t)-1) m_RecordCount += changedBy; }
    };


    class TLVRecordBuilder
    {
    protected:

        TLVRecordBuilder();

        TLVRecordBuilder(uint8_t recType, const uint8_t* recValue, uint8_t recValueLen);

        TLVRecordBuilder(uint8_t recType, uint8_t recValue);

        TLVRecordBuilder(uint8_t recType, uint16_t recValue);

        TLVRecordBuilder(uint8_t recType, uint32_t recValue);

        TLVRecordBuilder(uint8_t recType, const IPv4Address& recValue);

        TLVRecordBuilder(uint8_t recType, const std::string& recValue);

        TLVRecordBuilder(const TLVRecordBuilder& other);

        virtual ~TLVRecordBuilder();

        void init(uint8_t recType, const uint8_t* recValue, uint8_t recValueLen);

        uint8_t* m_RecValue;
        uint8_t m_RecValueLen;
        uint8_t m_RecType;
    };
}
#endif // PACKETPP_TLV_DATA