TLVData.h

Go to the documentation of this file.

#pragma once
 
#include "Layer.h"
#include "IpAddress.h"
#include <string.h>
#include <type_traits>
 
 
namespace pcpp
{
    template <typename TRecType, typename TRecLen> class TLVRecord
    {
    protected:
#pragma pack(push, 1)
        struct TLVRawData
        {
            TRecType recordType;
            TRecLen recordLen;
            uint8_t recordValue[];
        };
#pragma pack(pop)
 
        TLVRawData* m_Data;
 
    public:
        TLVRecord(uint8_t* recordRawData)
        {
            assign(recordRawData);
        }
 
        TLVRecord(const TLVRecord& other)
        {
            m_Data = other.m_Data;
        }
 
        virtual ~TLVRecord() = default;
 
        void assign(uint8_t* recordRawData)
        {
            m_Data = reinterpret_cast<TLVRawData*>(recordRawData);
        }
 
        static bool canAssign(const uint8_t* recordRawData, size_t tlvDataLen)
        {
            return recordRawData != nullptr &&
                   tlvDataLen >= (sizeof(TLVRawData::recordType) + sizeof(TLVRawData::recordLen));
        }
 
        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
        {
            if (m_Data == nullptr)
                return 0;
 
            return m_Data->recordType;
        }
 
        uint8_t* getValue() const
        {
            if (m_Data == nullptr)
                return nullptr;
 
            return m_Data->recordValue;
        }
 
        bool isNull() const
        {
            return (m_Data == nullptr);
        }
 
        bool isNotNull() const
        {
            return (m_Data != nullptr);
        }
 
        uint8_t* getRecordBasePtr() const
        {
            return reinterpret_cast<uint8_t*>(m_Data);
        }
 
        void purgeRecordData()
        {
            if (!isNull())
            {
                delete[] m_Data;
                m_Data = nullptr;
            }
        }
 
        template <typename T> T getValueAs(size_t offset = 0) const
        {
            static_assert(std::is_trivially_copyable<T>::value && std::is_default_constructible<T>::value &&
                              !std::is_pointer<T>::value,
                          "TLVRecord::getValueAs<T>() requires T to be a non-pointer, "
                          "default-constructible, trivially copyable type");
 
            if (getDataSize() < sizeof(T) + offset)
            {
                return T{};
            }
 
            T result;
            memcpy(&result, m_Data->recordValue + getValueOffset() + offset, sizeof(T));
            return result;
        }
 
        template <typename T> bool setValue(T newValue, int valueOffset = 0)
        {
            static_assert(std::is_trivially_copyable<T>::value && !std::is_pointer<T>::value,
                          "TLVRecord::setValue<T>() requires T to be a non-pointer, trivially copyable type");
 
            if (getDataSize() < sizeof(T))
            {
                return false;
            }
 
            memcpy(m_Data->recordValue + getValueOffset() + valueOffset, &newValue, sizeof(T));
            return true;
        }
 
        virtual size_t getTotalSize() const = 0;
 
        virtual size_t getDataSize() const = 0;
 
    protected:
        virtual size_t getValueOffset() const
        {
            return 0;
        }
    };
 
    template <typename TLVRecordType> class TLVRecordReader
    {
    private:
        mutable size_t m_RecordCount;
 
    public:
        TLVRecordReader()
        {
            m_RecordCount = static_cast<size_t>(-1);
        }
 
        TLVRecordReader(const TLVRecordReader& other)
        {
            m_RecordCount = other.m_RecordCount;
        }
 
        virtual ~TLVRecordReader() = default;
 
        TLVRecordReader& operator=(const TLVRecordReader& other)
        {
            m_RecordCount = other.m_RecordCount;
            return *this;
        }
 
        // cppcheck-suppress functionStatic
        TLVRecordType getFirstTLVRecord(uint8_t* tlvDataBasePtr, size_t tlvDataLen) const
        {
            TLVRecordType resRec(nullptr);  // for NRVO optimization
            if (!TLVRecordType::canAssign(tlvDataBasePtr, tlvDataLen))
                return resRec;
 
            resRec.assign(tlvDataBasePtr);
            // resRec pointer is out-bounds of the TLV records memory
            if (resRec.getRecordBasePtr() + resRec.getTotalSize() > tlvDataBasePtr + tlvDataLen)
                resRec.assign(nullptr);
 
            // check if there are records at all and the total size is not zero
            if (!resRec.isNull() && (tlvDataLen == 0 || resRec.getTotalSize() == 0))
                resRec.assign(nullptr);
 
            return resRec;
        }
 
        // cppcheck-suppress [constParameterReference, functionStatic]
        TLVRecordType getNextTLVRecord(TLVRecordType& record, const uint8_t* tlvDataBasePtr, size_t tlvDataLen) const
        {
            TLVRecordType resRec(nullptr);  // for NRVO optimization
 
            if (record.isNull())
                return resRec;
 
            if (!TLVRecordType::canAssign(record.getRecordBasePtr() + record.getTotalSize(),
                                          tlvDataBasePtr - record.getRecordBasePtr() + tlvDataLen -
                                              record.getTotalSize()))
                return resRec;
 
            resRec.assign(record.getRecordBasePtr() + record.getTotalSize());
 
            if (resRec.getTotalSize() == 0)
                resRec.assign(nullptr);
 
            // resRec pointer is out-bounds of the TLV records memory
            if ((resRec.getRecordBasePtr() - tlvDataBasePtr) < 0)
                resRec.assign(nullptr);
 
            // resRec pointer is out-bounds of the TLV records memory
            if (!resRec.isNull() && resRec.getRecordBasePtr() + resRec.getTotalSize() > tlvDataBasePtr + tlvDataLen)
                resRec.assign(nullptr);
 
            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(nullptr);
            return curRec;  // for NRVO optimization
        }
 
        size_t getTLVRecordCount(uint8_t* tlvDataBasePtr, size_t tlvDataLen) const
        {
            if (m_RecordCount != static_cast<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 != static_cast<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);
    };
}  // namespace pcpp