TcpLayer.h

Go to the documentation of this file.

#pragma once
 
#include "DeprecationUtils.h"
#include "Layer.h"
#include "TLVData.h"
#include <string.h>
#include <algorithm>
#include <iterator>
 
#define PCPP_INTERNAL_DEPRECATE_TCP_OPTION_TYPE_MSG                                                                    \
    "enum TcpOptionType is deprecated; Use enum class TcpOptionEnumType instead"
 
 
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 accurateEcnFlag : 1;
        uint16_t reserved : 3;
        uint16_t dataOffset : 4;
        uint16_t finFlag : 1;
        uint16_t synFlag : 1;
        uint16_t rstFlag : 1;
        uint16_t pshFlag : 1;
        uint16_t ackFlag : 1;
        uint16_t urgFlag : 1;
        uint16_t eceFlag : 1;
        uint16_t cwrFlag : 1;
#elif (BYTE_ORDER == BIG_ENDIAN)
        uint16_t dataOffset : 4;
        uint16_t reserved : 3;
        uint16_t accurateEcnFlag : 1;
        uint16_t cwrFlag : 1;
        uint16_t eceFlag : 1;
        uint16_t urgFlag : 1;
        uint16_t ackFlag : 1;
        uint16_t pshFlag : 1;
        uint16_t rstFlag : 1;
        uint16_t synFlag : 1;
        uint16_t finFlag : 1;
#else
#   error "Endian is not LE nor BE..."
#endif
        uint16_t windowSize;
        uint16_t headerChecksum;
        uint16_t urgentPointer;
    };
#pragma pack(pop)
    static_assert(sizeof(tcphdr) == 20, "tcphdr size is not 20 bytes");
 
    enum TcpOptionType : uint8_t
    {
        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
    };
 
    enum class TcpOptionEnumType : uint8_t
    {
        Nop = 1,
        Eol = 0,
        Mss = 2,
        Window = 3,
        SackPerm = 4,
        Sack = 5,
        Echo = 6,
        EchoReply = 7,
        Timestamp = 8,
        Cc = 11,
        CcNew = 12,
        CcEcho = 13,
        Md5 = 19,
        MpTcp = 0x1e,
        Scps = 20,
        Snack = 21,
        RecBound = 22,
        CorrExp = 23,
        Qs = 27,
        UserTo = 28,
        ExpFd = 0xfd,
        ExpFe = 0xfe,
        RvbdProbe = 76,
        RvbdTrpy = 78,
        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:
        explicit TcpOption(uint8_t* optionRawData) : TLVRecord(optionRawData)
        {}
 
        ~TcpOption() override = default;
 
        PCPP_DEPRECATED("Use getTcpOptionEnumType instead")
        TcpOptionType getTcpOptionType() const
        {
            return getTcpOptionType(m_Data);
        }
 
        TcpOptionEnumType getTcpOptionEnumType() const
        {
            return getTcpOptionEnumType(m_Data);
        }
 
        static bool canAssign(const uint8_t* recordRawData, size_t tlvDataLen)
        {
            const auto* data = reinterpret_cast<const TLVRawData*>(recordRawData);
            if (data == nullptr)
                return false;
 
            if (tlvDataLen < sizeof(TLVRawData::recordType))
                return false;
 
            const auto recordType = getTcpOptionEnumType(data);
            if (recordType == TcpOptionEnumType::Nop || recordType == TcpOptionEnumType::Eol)
                return true;
 
            return TLVRecord<uint8_t, uint8_t>::canAssign(recordRawData, tlvDataLen);
        }
 
        // implement abstract methods
 
        size_t getTotalSize() const override
        {
            if (m_Data == nullptr)
                return 0;
 
            const auto recordType = getTcpOptionEnumType(m_Data);
            if (recordType == TcpOptionEnumType::Nop || recordType == TcpOptionEnumType::Eol)
                return sizeof(uint8_t);
 
            return static_cast<size_t>(m_Data->recordLen);
        }
 
        size_t getDataSize() const override
        {
            if (m_Data == nullptr)
                return 0;
 
            const auto recordType = getTcpOptionEnumType(m_Data);
            if (recordType == TcpOptionEnumType::Nop || recordType == TcpOptionEnumType::Eol)
                return 0;
 
            return static_cast<size_t>(m_Data->recordLen) - (2 * sizeof(uint8_t));
        }
 
    private:
        static TcpOptionType getTcpOptionType(const TLVRawData* optionRawData)
        {
            if (optionRawData == nullptr)
                return TcpOptionType::TCPOPT_Unknown;
 
            return static_cast<TcpOptionType>(optionRawData->recordType);
        }
 
        static TcpOptionEnumType getTcpOptionEnumType(const TLVRawData* optionRawData)
        {
            if (optionRawData == nullptr)
                return TcpOptionEnumType::Unknown;
 
            return static_cast<TcpOptionEnumType>(optionRawData->recordType);
        }
    };
 
    class TcpOptionBuilder : public TLVRecordBuilder
    {
 
    public:
        enum NopEolOptionTypes : uint8_t
        {
            NOP,
            EOL
        };
 
        enum class NopEolOptionEnumType : uint8_t
        {
            Nop,
            Eol
        };
 
        PCPP_DEPRECATED(PCPP_INTERNAL_DEPRECATE_TCP_OPTION_TYPE_MSG)
        TcpOptionBuilder(TcpOptionType optionType, const uint8_t* optionValue, uint8_t optionValueLen)
            : TLVRecordBuilder(static_cast<uint8_t>(optionType), optionValue, optionValueLen)
        {}
 
        TcpOptionBuilder(TcpOptionEnumType optionType, const uint8_t* optionValue, uint8_t optionValueLen)
            : TLVRecordBuilder(static_cast<uint8_t>(optionType), optionValue, optionValueLen)
        {}
 
        PCPP_DEPRECATED(PCPP_INTERNAL_DEPRECATE_TCP_OPTION_TYPE_MSG)
        TcpOptionBuilder(TcpOptionType optionType, uint8_t optionValue)
            : TLVRecordBuilder(static_cast<uint8_t>(optionType), optionValue)
        {}
 
        TcpOptionBuilder(TcpOptionEnumType optionType, uint8_t optionValue)
            : TLVRecordBuilder(static_cast<uint8_t>(optionType), optionValue)
        {}
 
        PCPP_DEPRECATED(PCPP_INTERNAL_DEPRECATE_TCP_OPTION_TYPE_MSG)
        TcpOptionBuilder(TcpOptionType optionType, uint16_t optionValue)
            : TLVRecordBuilder(static_cast<uint8_t>(optionType), optionValue)
        {}
 
        TcpOptionBuilder(TcpOptionEnumType optionType, uint16_t optionValue)
            : TLVRecordBuilder(static_cast<uint8_t>(optionType), optionValue)
        {}
 
        PCPP_DEPRECATED(PCPP_INTERNAL_DEPRECATE_TCP_OPTION_TYPE_MSG)
        TcpOptionBuilder(TcpOptionType optionType, uint32_t optionValue)
            : TLVRecordBuilder(static_cast<uint8_t>(optionType), optionValue)
        {}
 
        TcpOptionBuilder(TcpOptionEnumType optionType, uint32_t optionValue)
            : TLVRecordBuilder(static_cast<uint8_t>(optionType), optionValue)
        {}
 
        PCPP_DEPRECATED("enum NopEolOptionTypes is deprecated; Use enum class NopEolOptionEnumType instead")
        explicit TcpOptionBuilder(NopEolOptionTypes optionType);
 
        explicit TcpOptionBuilder(NopEolOptionEnumType 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() override = default;
 
        TcpLayer(const TcpLayer& other);
 
        TcpLayer& operator=(const TcpLayer& other);
 
        tcphdr* getTcpHeader() const
        {
            return reinterpret_cast<tcphdr*>(m_Data);
        }
 
        uint16_t getSrcPort() const;
 
        uint16_t getDstPort() const;
 
        PCPP_DEPRECATED(PCPP_INTERNAL_DEPRECATE_TCP_OPTION_TYPE_MSG)
        TcpOption getTcpOption(TcpOptionType option) const;
 
        TcpOption getTcpOption(TcpOptionEnumType option) const;
 
        TcpOption getFirstTcpOption() const;
 
        TcpOption getNextTcpOption(TcpOption& tcpOption) const;
 
        size_t getTcpOptionCount() const;
 
        TcpOption addTcpOption(const TcpOptionBuilder& optionBuilder);
 
        PCPP_DEPRECATED("Use insertTcpOptionAfter instead")
        TcpOption addTcpOptionAfter(const TcpOptionBuilder& optionBuilder,
                                    TcpOptionType prevOptionType = TcpOptionType::TCPOPT_Unknown);
 
        TcpOption insertTcpOptionAfter(const TcpOptionBuilder& optionBuilder,
                                       TcpOptionEnumType prevOptionType = TcpOptionEnumType::Unknown);
 
        PCPP_DEPRECATED(PCPP_INTERNAL_DEPRECATE_TCP_OPTION_TYPE_MSG)
        bool removeTcpOption(TcpOptionType optionType);
 
        bool removeTcpOption(TcpOptionEnumType optionType);
 
        bool removeAllTcpOptions();
 
        uint16_t calculateChecksum(bool writeResultToPacket);
 
        static inline bool isDataValid(const uint8_t* data, size_t dataLen);
 
        // implement abstract methods
 
        void parseNextLayer() override;
 
        size_t getHeaderLen() const override
        {
            return getTcpHeader()->dataOffset * 4;
        }
 
        void computeCalculateFields() override;
 
        std::string toString() const override;
 
        OsiModelLayer getOsiModelLayer() const override
        {
            return OsiModelTransportLayer;
        }
 
        struct SerializedFields : Layer::SerializedFields
        {
            static std::vector<FieldDescriptor> all()
            {
                auto result = Layer::SerializedFields::all();
                std::initializer_list<FieldDescriptor> extra{ SrcPort,    DstPort,  SequenceNumber, TcpFlags,
                                                              WindowSize, Checksum, Options };
                std::copy(extra.begin(), extra.end(), std::back_inserter(result));
                return result;
            }
 
            static const FieldDescriptor SrcPort;
 
            static const FieldDescriptor DstPort;
 
            static const FieldDescriptor SequenceNumber;
 
            static const FieldDescriptor TcpFlags;
 
            static const FieldDescriptor TcpFlag;
 
            static const FieldDescriptor WindowSize;
 
            static const FieldDescriptor Checksum;
 
            static const FieldDescriptor Options;
 
            static const FieldDescriptor Option;
        };
 
    protected:
        void serializeLayer(ObjectScope& serializer) const override;
 
    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
 
#undef PCPP_INTERNAL_DEPRECATE_TCP_OPTION_TYPE_MSG