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
{
    template<typename TRecType, typename TRecLen>
    class TLVRecord
    {
    protected:

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

        TLVRawData* m_Data;

    public:

        TLVRecord(uint8_t* recordRawData)
        {
            assign(recordRawData);
        }

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

        virtual ~TLVRecord() { }

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

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

        bool operator==(const TLVRecord& rhs) const
        {
            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);
        }

        bool operator!=(const TLVRecord& rhs) const
        {
            return !operator==(rhs);
        }

        TRecType getType() const { return m_Data->recordType; }

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

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

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

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

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

        template<typename T>
        T getValueAs(size_t offset = 0) const
        {
            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() const = 0;
    };


    template<typename TLVRecordType>
    class TLVRecordReader
    {
    private:
        mutable 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) const
        {
            // In most cases tlvDataLen is not zero and the size is correct therefore the overhead is not significant if the checks will be done later
            TLVRecordType resRec(tlvDataBasePtr); // for NRVO optimization

            // check if there are records at all and the total size is not zero
            if (tlvDataLen == 0 || resRec.getTotalSize() == 0)
                resRec.assign(NULL);

            return resRec;
        }

        TLVRecordType getNextTLVRecord(TLVRecordType& record, uint8_t* tlvDataBasePtr, size_t tlvDataLen) const
        {
            TLVRecordType resRec(NULL); // for NRVO optimization

            if (record.isNull())
                return resRec;

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

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

            resRec.assign(record.getRecordBasePtr() + record.getTotalSize());
            if (resRec.getTotalSize() == 0)
                resRec.assign(NULL);

            return resRec;
        }

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

            curRec.assign(NULL);
            return curRec; // for NRVO optimization
        }

        size_t getTLVRecordCount(uint8_t* tlvDataBasePtr, size_t tlvDataLen) const
        {
            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(uint32_t recType, const uint8_t* recValue, uint8_t recValueLen);

        TLVRecordBuilder(uint32_t recType, uint8_t recValue);

        TLVRecordBuilder(uint32_t recType, uint16_t recValue);

        TLVRecordBuilder(uint32_t recType, uint32_t recValue);

        TLVRecordBuilder(uint32_t recType, const IPv4Address& recValue);

        TLVRecordBuilder(uint32_t recType, const std::string& recValue, bool valueIsHexString = false);

        TLVRecordBuilder(const TLVRecordBuilder& other);

        TLVRecordBuilder& operator=(const TLVRecordBuilder& other);

        virtual ~TLVRecordBuilder();

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

        uint8_t* m_RecValue;
        size_t m_RecValueLen;
        uint32_t m_RecType;
    
    private:

        void copyData(const TLVRecordBuilder& other);
    };
}
#endif // PACKETPP_TLV_DATA