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
    {
    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; }
 
        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 */