IPv4Layer.h

Go to the documentation of this file.

#ifndef PACKETPP_IPV4_LAYER
#define PACKETPP_IPV4_LAYER

#include "Layer.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();
        }
    };


    struct IPv4OptionData
    {
    public:
        uint8_t opCode;
        uint8_t len;
        uint8_t value[];

        template<typename T>
        T getValueAs(int valueOffset = 0)
        {
            if (getTotalSize() <= 2*sizeof(uint8_t) + valueOffset)
                return 0;
            if (getTotalSize() - 2*sizeof(uint8_t) - valueOffset < sizeof(T))
                return 0;

            T result;
            memcpy(&result, value+valueOffset, sizeof(T));
            return result;
        }

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

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

            uint8_t valueOffset = (uint8_t)(1);

            while (valueOffset < dataSize)
            {
                uint32_t curValue;
                memcpy(&curValue, value+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 (getType() != IPV4OPT_Timestamp)
                return res;

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

            res.type = (IPv4TimestampOptionValue::TimestampType)value[1];

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

            while (valueOffset < dataSize)
            {
                uint32_t curValue;
                memcpy(&curValue, value+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;
        }

        size_t getTotalSize() const
        {
            if (opCode == (uint8_t)IPV4OPT_EndOfOtionsList || opCode == (uint8_t)IPV4OPT_NOP)
                return sizeof(uint8_t);

            return (size_t)len;
        }

        size_t getDataSize()
        {
            if (opCode == (uint8_t)IPV4OPT_EndOfOtionsList || opCode == (uint8_t)IPV4OPT_NOP)
                return (size_t)0;

            return (size_t)len - (2*sizeof(uint8_t));
        }

        inline IPv4OptionTypes getType() { return (IPv4OptionTypes)opCode; }

    private:

        // private c'tor which isn't implemented to make this struct impossible to construct
        IPv4OptionData();
    };



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

        IPv4OptionData* getOptionData(IPv4OptionTypes option);

        IPv4OptionData* getFirstOptionData();

        IPv4OptionData* getNextOptionData(IPv4OptionData* option);

        size_t getOptionsCount();

        IPv4OptionData* addOption(IPv4OptionTypes optionType, uint8_t optionDataLength, const uint8_t* optionData);

        IPv4OptionData* addOption(IPv4OptionTypes optionType, const std::vector<IPv4Address>& ipList);

        IPv4OptionData* addTimestampOption(const IPv4TimestampOptionValue& timestampValue);

        IPv4OptionData* addOptionAfter(IPv4OptionTypes optionType, uint8_t optionDataLength, const uint8_t* optionData, IPv4OptionTypes prevOption = IPV4OPT_Unknown);

        IPv4OptionData* addOptionAfter(IPv4OptionTypes optionType, const std::vector<IPv4Address>& ipList, IPv4OptionTypes prevOption = IPV4OPT_Unknown);

        IPv4OptionData* addTimestampOptionAfter(const IPv4TimestampOptionValue& timestampValue, IPv4OptionTypes prevOption = 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:
        size_t m_OptionCount;
        int m_NumOfTrailingBytes;
        int m_TempHeaderExtension;

        void copyLayerData(const IPv4Layer& other);
        IPv4OptionData* castPtrToOptionData(uint8_t* ptr);
        IPv4OptionData* addOptionAt(IPv4OptionTypes optionType, uint8_t optionDataLength, const uint8_t* optionData, int offset);
        void adjustOptionsTrailer(size_t totalOptSize);
        void buildIPListOptionData(const std::vector<IPv4Address>& ipList, uint8_t** optionData, int& optionDataLength);
        void buildTimestampOptionData(const IPv4TimestampOptionValue& timestampVal, uint8_t** optionData, int& optionDataLength);
        void incOptionCount(int val);
        void setOptionCount(int val);
        void initLayer();
        void initLayerInPacket(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet, bool setTotalLenAsDataLen);
    };

} // namespace pcpp

#endif /* PACKETPP_IPV4_LAYER */