IPv4Layer.h

Go to the documentation of this file.

#pragma once
 
#include "Layer.h"
#include "TLVData.h"
#include "IpAddress.h"
#include "IPLayer.h"
#include <string.h>
#include <vector>
#include <algorithm>
#include <iterator>
 
 
namespace pcpp
{
#pragma pack(push, 1)
    struct iphdr
    {
#if (BYTE_ORDER == LITTLE_ENDIAN)
        uint8_t internetHeaderLength : 4,
            ipVersion : 4;
#else
        uint8_t ipVersion : 4,
            internetHeaderLength : 4;
#endif
        uint8_t typeOfService;
        uint16_t totalLength;
        uint16_t ipId;
        uint16_t fragmentOffset;
        uint8_t timeToLive;
        uint8_t protocol;
        uint16_t headerChecksum;
        uint32_t ipSrc;
        uint32_t ipDst;
        // The options start here.
    };
#pragma pack(pop)
    static_assert(sizeof(iphdr) == 20, "iphdr size is not 20 bytes");
 
    enum IPProtocolTypes
    {
        PACKETPP_IPPROTO_IP = 0,
        PACKETPP_IPPROTO_HOPOPTS = 0,
        PACKETPP_IPPROTO_ICMP = 1,
        PACKETPP_IPPROTO_IGMP = 2,
        PACKETPP_IPPROTO_IPIP = 4,
        PACKETPP_IPPROTO_TCP = 6,
        PACKETPP_IPPROTO_EGP = 8,
        PACKETPP_IPPROTO_PUP = 12,
        PACKETPP_IPPROTO_UDP = 17,
        PACKETPP_IPPROTO_IDP = 22,
        PACKETPP_IPPROTO_IPV6 = 41,
        PACKETPP_IPPROTO_ROUTING = 43,
        PACKETPP_IPPROTO_FRAGMENT = 44,
        PACKETPP_IPPROTO_GRE = 47,
        PACKETPP_IPPROTO_ESP = 50,
        PACKETPP_IPPROTO_AH = 51,
        PACKETPP_IPPROTO_ICMPV6 = 58,
        PACKETPP_IPPROTO_NONE = 59,
        PACKETPP_IPPROTO_DSTOPTS = 60,
        PACKETPP_IPPROTO_VRRP = 112,
        PACKETPP_IPPROTO_RAW = 255,
        PACKETPP_IPPROTO_MAX
    };
 
    enum IPv4OptionTypes
    {
        IPV4OPT_EndOfOptionsList = 0,
        IPV4OPT_NOP = 1,
        IPV4OPT_RecordRoute = 7,
        IPV4OPT_MTUProbe = 11,
        IPV4OPT_MTUReply = 12,
        IPV4OPT_QuickStart = 25,
        IPV4OPT_Timestamp = 68,
        IPV4OPT_Traceroute = 82,
        IPV4OPT_Security = 130,
        IPV4OPT_LooseSourceRoute = 131,
        IPV4OPT_ExtendedSecurity = 133,
        IPV4OPT_CommercialSecurity = 134,
        IPV4OPT_StreamID = 136,
        IPV4OPT_StrictSourceRoute = 137,
        IPV4OPT_ExtendedInternetProtocol = 145,
        IPV4OPT_AddressExtension = 147,
        IPV4OPT_RouterAlert = 148,
        IPV4OPT_SelectiveDirectedBroadcast = 149,
        IPV4OPT_DynamicPacketState = 151,
        IPV4OPT_UpstreamMulticastPkt = 152,
        IPV4OPT_Unknown
    };
 
#define PCPP_IP_DONT_FRAGMENT 0x40
#define PCPP_IP_MORE_FRAGMENTS 0x20
 
    struct IPv4TimestampOptionValue
    {
        enum TimestampType
        {
            TimestampOnly = 0,
            TimestampAndIP = 1,
            TimestampsForPrespecifiedIPs = 2,
            Unknown = 3
        };
 
        TimestampType type;
 
        std::vector<uint32_t> timestamps;
 
        std::vector<IPv4Address> ipAddresses;
 
        IPv4TimestampOptionValue() : type(IPv4TimestampOptionValue::Unknown)
        {}
 
        void clear()
        {
            type = IPv4TimestampOptionValue::Unknown;
            timestamps.clear();
            ipAddresses.clear();
        }
    };
 
    class IPv4Option : public TLVRecord<uint8_t, uint8_t>
    {
    public:
        explicit IPv4Option(uint8_t* optionRawData) : TLVRecord(optionRawData)
        {}
 
        ~IPv4Option() override = default;
 
        std::vector<IPv4Address> getValueAsIpList() const
        {
            std::vector<IPv4Address> res;
 
            if (m_Data == nullptr)
                return res;
 
            size_t dataSize = getDataSize();
            if (dataSize < 2)
                return res;
 
            uint8_t valueOffset = static_cast<uint8_t>(1);
 
            while (static_cast<size_t>(valueOffset) < dataSize)
            {
                uint32_t curValue;
                memcpy(&curValue, m_Data->recordValue + valueOffset, sizeof(uint32_t));
                if (curValue == 0)
                    break;
 
                res.push_back(IPv4Address(curValue));
 
                valueOffset += static_cast<uint8_t>(4);
            }
 
            return res;
        }
 
        IPv4TimestampOptionValue getTimestampOptionValue() const
        {
            IPv4TimestampOptionValue res;
            res.clear();
 
            if (m_Data == nullptr)
                return res;
 
            if (getIPv4OptionType() != IPV4OPT_Timestamp)
                return res;
 
            size_t dataSize = getDataSize();
            if (dataSize < 2)
                return res;
 
            res.type = static_cast<IPv4TimestampOptionValue::TimestampType>(m_Data->recordValue[1]);
 
            uint8_t valueOffset = static_cast<uint8_t>(2);
            bool readIPAddr = (res.type == IPv4TimestampOptionValue::TimestampAndIP);
 
            while (static_cast<size_t>(valueOffset) < dataSize)
            {
                uint32_t curValue;
                memcpy(&curValue, m_Data->recordValue + valueOffset, sizeof(uint32_t));
                if (curValue == 0)
                    break;
 
                if (readIPAddr)
                    res.ipAddresses.push_back(IPv4Address(curValue));
                else
                    res.timestamps.push_back(curValue);
 
                if (res.type == IPv4TimestampOptionValue::TimestampAndIP)
                    readIPAddr = !readIPAddr;
 
                valueOffset += static_cast<uint8_t>(4);
            }
 
            return res;
        }
 
        IPv4OptionTypes getIPv4OptionType() const
        {
            return getIPv4OptionType(m_Data);
        }
 
        static bool canAssign(const uint8_t* recordRawData, size_t tlvDataLen)
        {
            auto data = reinterpret_cast<TLVRawData const*>(recordRawData);
            if (data == nullptr)
                return false;
 
            if (tlvDataLen < sizeof(TLVRawData::recordType))
                return false;
 
            if (getIPv4OptionType(data) == static_cast<uint8_t>(IPV4OPT_EndOfOptionsList) ||
                data->recordType == static_cast<uint8_t>(IPV4OPT_NOP))
                return true;
 
            return TLVRecord<uint8_t, uint8_t>::canAssign(recordRawData, tlvDataLen);
        }
 
        // implement abstract methods
 
        size_t getTotalSize() const override
        {
            if (m_Data == nullptr)
                return 0;
 
            if (getIPv4OptionType() == static_cast<uint8_t>(IPV4OPT_EndOfOptionsList) ||
                m_Data->recordType == static_cast<uint8_t>(IPV4OPT_NOP))
                return sizeof(uint8_t);
 
            return static_cast<size_t>(m_Data->recordLen);
        }
 
        size_t getDataSize() const override
        {
            if (m_Data == nullptr)
                return 0;
 
            if (getIPv4OptionType() == static_cast<uint8_t>(IPV4OPT_EndOfOptionsList) ||
                m_Data->recordType == static_cast<uint8_t>(IPV4OPT_NOP))
                return 0;
 
            return static_cast<size_t>(m_Data->recordLen) - (2 * sizeof(uint8_t));
        }
 
    private:
        static IPv4OptionTypes getIPv4OptionType(const TLVRawData* data)
        {
            if (data == nullptr)
                return IPV4OPT_Unknown;
 
            return static_cast<IPv4OptionTypes>(data->recordType);
        }
    };
 
    class IPv4OptionBuilder : public TLVRecordBuilder
    {
    private:
        bool m_BuilderParamsValid;
 
    public:
        IPv4OptionBuilder(IPv4OptionTypes optionType, const uint8_t* optionValue, uint8_t optionValueLen)
            : TLVRecordBuilder((uint8_t)optionType, optionValue, optionValueLen)
        {
            m_BuilderParamsValid = true;
        }
 
        IPv4OptionBuilder(IPv4OptionTypes optionType, uint16_t optionValue)
            : TLVRecordBuilder((uint8_t)optionType, optionValue)
        {
            m_BuilderParamsValid = true;
        }
 
        IPv4OptionBuilder(IPv4OptionTypes optionType, const std::vector<IPv4Address>& ipList);
 
        explicit IPv4OptionBuilder(const IPv4TimestampOptionValue& timestampValue);
 
        IPv4Option build() const;
    };
 
    class IPv4Layer : public Layer, public IPLayer
    {
    public:
        IPv4Layer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet);
 
        IPv4Layer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet, bool setTotalLenAsDataLen);
 
        IPv4Layer();
 
        IPv4Layer(const IPv4Address& srcIP, const IPv4Address& dstIP);
 
        IPv4Layer(const IPv4Layer& other);
 
        IPv4Layer& operator=(const IPv4Layer& other);
 
        iphdr* getIPv4Header() const
        {
            return reinterpret_cast<iphdr*>(m_Data);
        }
 
        IPAddress getSrcIPAddress() const override
        {
            return getSrcIPv4Address();
        }
 
        IPv4Address getSrcIPv4Address() const
        {
            return getIPv4Header()->ipSrc;
        }
 
        void setSrcIPv4Address(const IPv4Address& ipAddr)
        {
            getIPv4Header()->ipSrc = ipAddr.toInt();
        }
 
        IPAddress getDstIPAddress() const override
        {
            return getDstIPv4Address();
        }
 
        IPv4Address getDstIPv4Address() const
        {
            return getIPv4Header()->ipDst;
        }
 
        void setDstIPv4Address(const IPv4Address& ipAddr)
        {
            getIPv4Header()->ipDst = ipAddr.toInt();
        }
 
        bool isFragment() const;
 
        bool isFirstFragment() const;
 
        bool isLastFragment() const;
 
        uint8_t getFragmentFlags() const;
 
        uint16_t getFragmentOffset() const;
 
        IPv4Option getOption(IPv4OptionTypes option) const;
 
        IPv4Option getFirstOption() const;
 
        IPv4Option getNextOption(IPv4Option& option) const;
 
        size_t getOptionCount() const;
 
        IPv4Option addOption(const IPv4OptionBuilder& optionBuilder);
 
        IPv4Option addOptionAfter(const IPv4OptionBuilder& optionBuilder,
                                  IPv4OptionTypes prevOptionType = IPV4OPT_Unknown);
 
        bool removeOption(IPv4OptionTypes option);
 
        bool removeAllOptions();
 
        // implement abstract methods
 
        void parseNextLayer() override;
 
        size_t getHeaderLen() const override
        {
            return static_cast<size_t>(static_cast<uint16_t>(getIPv4Header()->internetHeaderLength) * 4) +
                   m_TempHeaderExtension;
        }
 
        void computeCalculateFields() override;
 
        std::string toString() const override;
 
        OsiModelLayer getOsiModelLayer() const override
        {
            return OsiModelNetworkLayer;
        }
 
        static inline bool isDataValid(const uint8_t* data, size_t dataLen);
 
        struct SerializedFields : Layer::SerializedFields
        {
            static std::vector<FieldDescriptor> all()
            {
                auto result = Layer::SerializedFields::all();
                std::initializer_list<FieldDescriptor> extra{ SrcIp,       DstIp,      IpId,           IpProtocol,
                                                              TotalLength, IsFragment, FragmentOffset, Options };
                std::copy(extra.begin(), extra.end(), std::back_inserter(result));
                return result;
            }
 
            static const FieldDescriptor SrcIp;
 
            static const FieldDescriptor DstIp;
 
            static const FieldDescriptor IpId;
 
            static const FieldDescriptor IpProtocol;
 
            static const FieldDescriptor TotalLength;
 
            static const FieldDescriptor IsFragment;
 
            static const FieldDescriptor FragmentOffset;
 
            static const FieldDescriptor Options;
 
            static const FieldDescriptor Option;
        };
 
    protected:
        void serializeLayer(ObjectScope& serializer) const override;
 
    private:
        int m_NumOfTrailingBytes;
        int m_TempHeaderExtension;
        TLVRecordReader<IPv4Option> m_OptionReader;
 
        void copyLayerData(const IPv4Layer& other);
        uint8_t* getOptionsBasePtr() const
        {
            return m_Data + sizeof(iphdr);
        }
        IPv4Option addOptionAt(const IPv4OptionBuilder& optionBuilder, int offset);
        void adjustOptionsTrailer(size_t totalOptSize);
        void initLayer();
        void initLayerInPacket(bool setTotalLenAsDataLen);
    };
 
    // implementation of inline methods
 
    bool IPv4Layer::isDataValid(const uint8_t* data, size_t dataLen)
    {
        const iphdr* hdr = reinterpret_cast<const iphdr*>(data);
        return canReinterpretAs<iphdr>(data, dataLen) && hdr->ipVersion == 4 && hdr->internetHeaderLength >= 5;
    }
 
}  // namespace pcpp