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_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
    {
    public:
 
        IPv4Option(uint8_t* optionRawData) : TLVRecord(optionRawData) { }
 
        ~IPv4Option() { }
 
        std::vector<IPv4Address> getValueAsIpList() const
        {
            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 ((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 == 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 ((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 == 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_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 == NULL)
                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);
 
        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);
 
        iphdr* getIPv4Header() const { return (iphdr*)m_Data; }
 
        IPv4Address getSrcIpAddress() const { return getIPv4Header()->ipSrc; }
 
        void setSrcIpAddress(const IPv4Address& ipAddr) { getIPv4Header()->ipSrc = ipAddr.toInt(); }
 
        IPv4Address getDstIpAddress() const { return getIPv4Header()->ipDst; }
 
        void setDstIpAddress(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(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet, 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 */