TcpLayer.h

Go to the documentation of this file.

#ifndef PACKETPP_TCP_LAYER
#define PACKETPP_TCP_LAYER

#include "Layer.h"
#include "TLVData.h"
#include <string.h>


namespace pcpp
{

#pragma pack(push,1)
    struct tcphdr
    {
        uint16_t portSrc;
        uint16_t portDst;
        uint32_t sequenceNumber;
        uint32_t ackNumber;
#if (BYTE_ORDER == LITTLE_ENDIAN)
        uint16_t reserved:4,
        dataOffset:4,
        finFlag:1,
        synFlag:1,
        rstFlag:1,
        pshFlag:1,
        ackFlag:1,
        urgFlag:1,
        eceFlag:1,
        cwrFlag:1;
#elif (BYTE_ORDER == BIG_ENDIAN)

        uint16_t dataOffset:4,
        reserved:4,
        cwrFlag:1,
        eceFlag:1,
        urgFlag:1,
        ackFlag:1,
        pshFlag:1,
        rstFlag:1,
        synFlag:1,
        finFlag:1;
#else
#error  "Endian is not LE nor BE..."
#endif

        uint16_t    windowSize;
        uint16_t    headerChecksum;
        uint16_t    urgentPointer;
    };
#pragma pack(pop)


    enum TcpOptionType
    {
        PCPP_TCPOPT_NOP =       1,
        PCPP_TCPOPT_EOL =       0,
        TCPOPT_MSS =            2,
        PCPP_TCPOPT_WINDOW =    3,
        TCPOPT_SACK_PERM =      4,
        PCPP_TCPOPT_SACK =      5,
        TCPOPT_ECHO =           6,
        TCPOPT_ECHOREPLY =      7,
        PCPP_TCPOPT_TIMESTAMP = 8,
        TCPOPT_CC =             11,
        TCPOPT_CCNEW =          12,
        TCPOPT_CCECHO =         13,
        TCPOPT_MD5 =            19,
        TCPOPT_MPTCP =          0x1e,
        TCPOPT_SCPS =           20,
        TCPOPT_SNACK =          21,
        TCPOPT_RECBOUND =       22,
        TCPOPT_CORREXP =        23,
        TCPOPT_QS =             27,
        TCPOPT_USER_TO =        28,
        TCPOPT_EXP_FD =         0xfd,
        TCPOPT_EXP_FE =         0xfe,
        TCPOPT_RVBD_PROBE =     76,
        TCPOPT_RVBD_TRPY =      78,
        TCPOPT_Unknown =        255
    };


    // TCP option lengths

#define PCPP_TCPOLEN_NOP            1

#define PCPP_TCPOLEN_EOL            1

#define PCPP_TCPOLEN_MSS            4

#define PCPP_TCPOLEN_WINDOW         3

#define PCPP_TCPOLEN_SACK_PERM      2

#define PCPP_TCPOLEN_SACK_MIN       2

#define PCPP_TCPOLEN_ECHO           6

#define PCPP_TCPOLEN_ECHOREPLY      6

#define PCPP_TCPOLEN_TIMESTAMP     10

#define PCPP_TCPOLEN_CC             6

#define PCPP_TCPOLEN_CCNEW          6

#define PCPP_TCPOLEN_CCECHO         6

#define PCPP_TCPOLEN_MD5           18

#define PCPP_TCPOLEN_MPTCP_MIN      8

#define PCPP_TCPOLEN_SCPS           4

#define PCPP_TCPOLEN_SNACK          6

#define PCPP_TCPOLEN_RECBOUND       2

#define PCPP_TCPOLEN_CORREXP        2

#define PCPP_TCPOLEN_QS             8

#define PCPP_TCPOLEN_USER_TO        4

#define PCPP_TCPOLEN_RVBD_PROBE_MIN 3

#define PCPP_TCPOLEN_RVBD_TRPY_MIN 16

#define PCPP_TCPOLEN_EXP_MIN        2


    class TcpOption : public TLVRecord<uint8_t, uint8_t>
    {
    public:

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

        ~TcpOption() { }

        TcpOptionType getTcpOptionType() const
        {
            if (m_Data == NULL)
                return TCPOPT_Unknown;

            return (TcpOptionType)m_Data->recordType;
        }

        // implement abstract methods

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

            if (m_Data->recordType == (uint8_t)PCPP_TCPOPT_NOP || m_Data->recordType == (uint8_t)PCPP_TCPOPT_EOL)
                return sizeof(uint8_t);

            return (size_t)m_Data->recordLen;
        }

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

            if (m_Data->recordType == (uint8_t)PCPP_TCPOPT_NOP || m_Data->recordType == (uint8_t)PCPP_TCPOPT_EOL)
                return (size_t)0;

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


    class TcpOptionBuilder : public TLVRecordBuilder
    {

    public:

        enum NopEolOptionTypes
        {
            NOP,
            EOL
        };

        TcpOptionBuilder(TcpOptionType optionType, const uint8_t* optionValue, uint8_t optionValueLen) :
            TLVRecordBuilder((uint8_t)optionType, optionValue, optionValueLen) {}

        TcpOptionBuilder(TcpOptionType optionType, uint8_t optionValue) :
            TLVRecordBuilder((uint8_t)optionType, optionValue) {}

        TcpOptionBuilder(TcpOptionType optionType, uint16_t optionValue) :
            TLVRecordBuilder((uint8_t)optionType, optionValue) {}

        TcpOptionBuilder(TcpOptionType optionType, uint32_t optionValue) :
            TLVRecordBuilder((uint8_t)optionType, optionValue) {}

        TcpOptionBuilder(NopEolOptionTypes optionType);

        TcpOption build() const;
    };


    class TcpLayer : public Layer
    {
    public:
        TcpLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet);

        TcpLayer();

        TcpLayer(uint16_t portSrc, uint16_t portDst);

        ~TcpLayer() {}

        TcpLayer(const TcpLayer& other);

        TcpLayer& operator=(const TcpLayer& other);

        tcphdr* getTcpHeader() const { return (tcphdr*)m_Data; }

        uint16_t getSrcPort() const;

        uint16_t getDstPort() const;

        TcpOption getTcpOption(TcpOptionType option) const;

        TcpOption getFirstTcpOption() const;

        TcpOption getNextTcpOption(TcpOption& tcpOption) const;

        size_t getTcpOptionCount() const;

        TcpOption addTcpOption(const TcpOptionBuilder& optionBuilder);

        TcpOption addTcpOptionAfter(const TcpOptionBuilder& optionBuilder, TcpOptionType prevOptionType = TCPOPT_Unknown);

        bool removeTcpOption(TcpOptionType optionType);

        bool removeAllTcpOptions();


        uint16_t calculateChecksum(bool writeResultToPacket);

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

        // implement abstract methods

        void parseNextLayer();

        size_t getHeaderLen() const { return getTcpHeader()->dataOffset*4 ;}

        void computeCalculateFields();

        std::string toString() const;

        OsiModelLayer getOsiModelLayer() const { return OsiModelTransportLayer; }

    private:

        TLVRecordReader<TcpOption> m_OptionReader;
        int m_NumOfTrailingBytes;

        void initLayer();
        uint8_t* getOptionsBasePtr() const { return m_Data + sizeof(tcphdr); }
        TcpOption addTcpOptionAt(const TcpOptionBuilder& optionBuilder, int offset);
        void adjustTcpOptionTrailer(size_t totalOptSize);
        void copyLayerData(const TcpLayer& other);
    };


    // implementation of inline methods

    bool TcpLayer::isDataValid(const uint8_t* data, size_t dataLen)
    {
        const tcphdr* hdr = reinterpret_cast<const tcphdr*>(data);
        return dataLen >= sizeof(tcphdr)
            && hdr->dataOffset >= 5 /* the minimum TCP header size */
            && dataLen >= hdr->dataOffset * sizeof(uint32_t);
    }

} // namespace pcpp

#endif /* PACKETPP_TCP_LAYER */