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 <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_RAW = 255,
        PACKETPP_IPPROTO_MAX
    };


    enum IPv4OptionTypes
    {
        IPV4OPT_EndOfOtionsList = 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
    {
    public:

        enum TimestampType
        {
            TimestampOnly = 0,
            TimestampAndIP = 1,
            TimestampsForPrespecifiedIPs = 2,
            Unknown = 3
        };

        TimestampType type;

        std::vector<uint32_t> timestamps;

        std::vector<IPv4Address> ipAddresses;

        void clear()
        {
            type = IPv4TimestampOptionValue::Unknown;
            timestamps.clear();
            ipAddresses.clear();
        }
    };


    class IPv4Option : public TLVRecord
    {
    public:

        IPv4Option(uint8_t* optionRawData) : TLVRecord(optionRawData) { }

        ~IPv4Option() { }

        std::vector<IPv4Address> getValueAsIpList()
        {
            std::vector<IPv4Address> res;

            if (m_Data == NULL)
                return res;

            size_t dataSize =  getDataSize();
            if (dataSize < 2)
                return res;

            uint8_t valueOffset = (uint8_t)(1);

            while (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()
        {
            IPv4TimestampOptionValue res;
            res.clear();

            if (m_Data == NULL)
                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 (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;
        }

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

            return (IPv4OptionTypes)m_Data->recordType;
        }


        // implement abstract methods

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

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

            return (size_t)m_Data->recordLen;
        }

        size_t getDataSize()
        {
            if (m_Data == NULL)
                return 0;

            if (getIPv4OptionType() == (uint8_t)IPV4OPT_EndOfOtionsList || 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);

        IPv4OptionBuilder(const IPv4TimestampOptionValue& timestampValue);

        IPv4Option build() const;
    };


    class IPv4Layer : public Layer
    {
    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);

        inline iphdr* getIPv4Header() { return (iphdr*)m_Data; }

        inline IPv4Address getSrcIpAddress() { return IPv4Address(getIPv4Header()->ipSrc); }

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

        inline IPv4Address getDstIpAddress() { return IPv4Address(getIPv4Header()->ipDst); }

        inline void setDstIpAddress(const IPv4Address& ipAddr) { getIPv4Header()->ipDst = ipAddr.toInt(); }

        bool isFragment();

        bool isFirstFragment();

        bool isLastFragment();

        uint8_t getFragmentFlags();

        uint16_t getFragmentOffset();

        IPv4Option getOption(IPv4OptionTypes option);

        IPv4Option getFirstOption();

        IPv4Option getNextOption(IPv4Option& option);

        size_t getOptionCount();

        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();

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

        void computeCalculateFields();

        std::string toString();

        OsiModelLayer getOsiModelLayer() { return OsiModelNetworkLayer; }

    private:
        int m_NumOfTrailingBytes;
        int m_TempHeaderExtension;
        TLVRecordReader<IPv4Option> m_OptionReader;

        void copyLayerData(const IPv4Layer& other);
        inline uint8_t* getOptionsBasePtr() { return m_Data + sizeof(iphdr); }
        IPv4Option addOptionAt(const IPv4OptionBuilder& optionBuilder, int offset);
        void adjustOptionsTrailer(size_t totalOptSize);
        void initLayer();
        void initLayerInPacket(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet, bool setTotalLenAsDataLen);
    };

} // namespace pcpp

#endif /* PACKETPP_IPV4_LAYER */