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)
        {
            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);
        }
 
 
        uint8_t 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(uint8_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(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);
 
        TLVRecordBuilder& operator=(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;
    
    private:
 
        void copyData(const TLVRecordBuilder& other);
    };
}
#endif // PACKETPP_TLV_DATA