IPv4Layer.h

Go to the documentation of this file.

#ifndef PACKETPP_IPV4_LAYER
#define PACKETPP_IPV4_LAYER

#include "Layer.h"
#include "TLVData.h"
#include "IpAddress.h"
#include "IPLayer.h"
#include <string.h>
#include <vector>


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)

    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() { }

        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 = (uint8_t)(1);

            while ((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 += (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 = (IPv4TimestampOptionValue::TimestampType)m_Data->recordValue[1];

            uint8_t valueOffset = (uint8_t)(2);
            bool readIPAddr = (res.type == IPv4TimestampOptionValue::TimestampAndIP);

            while ((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 += (uint8_t)(4);
            }

            return res;
        }

        IPv4OptionTypes getIPv4OptionType() const
        {
            if (m_Data == nullptr)
                return IPV4OPT_Unknown;

            return (IPv4OptionTypes)m_Data->recordType;
        }


        // implement abstract methods

        size_t getTotalSize() const
        {
            if (m_Data == nullptr)
                return 0;

            if (getIPv4OptionType() == (uint8_t)IPV4OPT_EndOfOptionsList || m_Data->recordType == (uint8_t)IPV4OPT_NOP)
                return sizeof(uint8_t);

            return (size_t)m_Data->recordLen;
        }

        size_t getDataSize() const
        {
            if (m_Data == nullptr)
                return 0;

            if (getIPv4OptionType() == (uint8_t)IPV4OPT_EndOfOptionsList || m_Data->recordType == (uint8_t)IPV4OPT_NOP)
                return (size_t)0;

            return (size_t)m_Data->recordLen - (2*sizeof(uint8_t));
        }
    };


    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 (iphdr*)m_Data; }

        IPAddress getSrcIPAddress() const { return getSrcIPv4Address(); }

        IPv4Address getSrcIPv4Address() const { return getIPv4Header()->ipSrc; }

        void setSrcIPv4Address(const IPv4Address& ipAddr) { getIPv4Header()->ipSrc = ipAddr.toInt(); }

        IPAddress getDstIPAddress() const { 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();

        size_t getHeaderLen() const { return (size_t)((uint16_t)(getIPv4Header()->internetHeaderLength) * 4) + m_TempHeaderExtension; }

        void computeCalculateFields();

        std::string toString() const;

        OsiModelLayer getOsiModelLayer() const { return OsiModelNetworkLayer; }

        static inline bool isDataValid(const uint8_t* data, size_t dataLen);

    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 dataLen >= sizeof(iphdr) && hdr->ipVersion == 4 && hdr->internetHeaderLength >= 5;
    }

} // namespace pcpp

#endif /* PACKETPP_IPV4_LAYER */