TcpLayer.h

Go to the documentation of this file.

#ifndef PACKETPP_TCP_LAYER
#define PACKETPP_TCP_LAYER

#include "Layer.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 TcpOption {
        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
    };


    // 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

    struct TcpOptionData
    {
    public:
        uint8_t option;
        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;
        }

        template<typename T>
        void setValue(T newValue, int valueOffset = 0)
        {
            memcpy(value+valueOffset, &newValue, sizeof(T));
        }

        inline size_t getTotalSize() const
        {
            if (option == (uint8_t)PCPP_TCPOPT_NOP || option == (uint8_t)PCPP_TCPOPT_EOL)
                return sizeof(uint8_t);

            return (size_t)len;
        }

        inline TcpOption getType() {return (TcpOption)option;}
    private:
        // private c'tor which isn't implemented to make this struct impossible to construct
        TcpOptionData();
    };


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

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

        TcpOptionData* getTcpOptionData(TcpOption option);

        TcpOptionData* getFirstTcpOptionData();

        TcpOptionData* getNextTcpOptionData(TcpOptionData* tcpOption);

        size_t getTcpOptionsCount();

        TcpOptionData* addTcpOption(TcpOption optionType, uint8_t optionLength, const uint8_t* optionData);

        TcpOptionData* addTcpOptionAfter(TcpOption optionType, uint8_t optionLength, const uint8_t* optionData, TcpOptionData* prevOption);

        bool removeTcpOption(TcpOption optionType);

        bool removeAllTcpOptions();


        uint16_t calculateChecksum(bool writeResultToPacket);

        // implement abstract methods

        void parseNextLayer();

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

        void computeCalculateFields();

        std::string toString();

        OsiModelLayer getOsiModelLayer() { return OsiModelTransportLayer; }

    private:

        size_t m_TcpOptionsCount;
        int m_NumOfTrailingBytes;

        void initLayer();
        TcpOptionData* castPtrToTcpOptionData(uint8_t* ptr);
        TcpOptionData* addTcpOptionAt(TcpOption optionType, uint8_t optionLength, const uint8_t* optionData, int offset);
        void adjustTcpOptionTrailer(size_t totalOptSize);
        void copyLayerData(const TcpLayer& other);
    };

} // namespace pcpp

#endif /* PACKETPP_TCP_LAYER */